1657

pending completion

Build # 1657

Build Type

Pull #467

travis-ci-com

Committed by

web-flow

Commit Message

Merge 942f3aa5f into 2d0f5eef9

Pull Request Pull Request #467: update kf-server json parse

Run Details

10811 of 23249 branches covered (46.5%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

22 existing lines in 7 files now uncovered.

25391 of 43938 relevant lines covered (57.79%)

559874.29 hits per line

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

81.85

/languages/thingtalk/dialogue_acts/recommendation.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 ThingpediaLoader from '../load-thingpedia';

import { SlotBag } from '../slot_bag';
import {
    AgentReplyOptions,
    ContextInfo,
    makeAgentReply,
    makeSimpleState,
    addActionParam,
    addNewItem,
} from '../state_manip';
import {
    isInfoPhraseCompatibleWithResult,
    findChainParam
} from './common';
import {
    refineFilterToAnswerQuestionOrChangeFilter,
    combinePreambleAndRequest,
    proposalReply
} from './refinement-helpers';
import {
    addSlotToBag,
} from './results';


export interface Recommendation {
    ctx : ContextInfo;
    topResult : Ast.DialogueHistoryResultItem;
    info : SlotBag|null;
    action : Ast.Invocation|null;
    hasLearnMore : boolean;
    hasAnythingElse : boolean;
}

export function recommendationKeyFn(rec : Recommendation) {
    return {
        functionName: rec.ctx.currentFunction!.qualifiedName
    };
}

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

    const results = ctx.results;
    assert(results && results.length > 0);
    const currentStmt = ctx.current!.stmt;
    const currentTable = currentStmt.expression;
    const last = currentTable.last;
    if (last instanceof Ast.SliceExpression && last.limit.toJS() !== 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 (const param of action.in_params) {
        if (param.value.equals(id))
            return { ctx, topResult, info: null, action, hasLearnMore: false, hasAnythingElse: false };
    }

    return null;
}

function makeArgMinMaxRecommendation(ctx : ContextInfo, name : Ast.Value, base : Ast.Expression, param : C.ParamSlot, direction : 'asc'|'desc') {
    const resultInfo = ctx.resultInfo!;
    if (!resultInfo.argMinMaxField)
        return null;
    if (!C.isSameFunction(base.schema!, ctx.currentFunction!))
        return null;
    if (!C.isSameFunction(param.schema, ctx.currentFunction!))
        return null;
    if (direction !== resultInfo.argMinMaxField[1] ||
        param.name !== resultInfo.argMinMaxField[0])
        return null;

    return makeRecommendation(ctx, name);
}

function makeRecommendation(ctx : ContextInfo, name : Ast.Value) {
    const results = ctx.results;
    assert(results && results.length > 0);
    const currentStmt = ctx.current!.stmt;
    const currentTable = currentStmt.expression;
    const last = currentTable.last;
    if (last instanceof Ast.SliceExpression && last.limit.toJS() !== 1)
        return null;

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

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

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

function makeThingpediaRecommendation(ctx : ContextInfo, info : SlotBag) {
    const results = ctx.results;
    assert(results && results.length > 0);
    const currentStmt = ctx.current!.stmt;
    const currentTable = currentStmt.expression;
    const last = currentTable.last;
    if (last instanceof Ast.SliceExpression && last.limit.toJS() !== 1)
        return null;

    const topResult = results[0];
    if (!isInfoPhraseCompatibleWithResult(topResult, info))
        return null;

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

function checkRecommendation(rec : Recommendation, info : SlotBag) {
    if (!isInfoPhraseCompatibleWithResult(rec.topResult, info))
        return null;

    // check that the filter uses the right set of parameters
    const resultInfo = rec.ctx.resultInfo!;
    if (resultInfo.projection !== null) {
        // check that all projected names are present
        for (const name of resultInfo.projection) {
            if (!info.has(name))
                return null;
        }
    }

    return {
        ctx: rec.ctx, topResult: rec.topResult,
        info,
        action: rec.action,
        hasLearnMore: rec.hasLearnMore,
        hasAnythingElse: rec.hasAnythingElse
    };
}

function checkActionForRecommendation(rec : Recommendation, action : Ast.Invocation) {
    if (!rec.topResult.value.id)
        return null;
    const resultType = rec.topResult.value.id.getType();

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

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

    return {
        ctx: rec.ctx, topResult: rec.topResult,
        info: rec.info,
        action,
        hasLearnMore: rec.hasLearnMore,
        hasAnythingElse: rec.hasAnythingElse
    };
}

// make a recommendation that looks like an answer, that is, "so and so is a ..."
function makeAnswerStyleRecommendation(rec : Recommendation, filter : C.FilterSlot) {
    assert(C.isSameFunction(rec.ctx.currentFunction!, filter.schema));
    const added = addSlotToBag(new SlotBag(rec.ctx.currentFunction), filter);
    if (!added)
        return null;

    return checkRecommendation(rec, added[0]);
}

export function recommendationSetLearnMore(rec : Recommendation) {
    return {
        ctx: rec.ctx, topResult: rec.topResult,
        info: rec.info,
        // reset the action to null if the agent explicitly asks to "learn more"
        action: null,
        hasLearnMore: true,
        hasAnythingElse: rec.hasAnythingElse
    };
}

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

    if (ctx.currentFunction!.is_list)
        return null;
    if (!C.isSameFunction(ctx.currentFunction!, info.schema!))
        return null;
    if (!isInfoPhraseCompatibleWithResult(topResult, info))
        return null;
    return {
        ctx, topResult,
        info,
        action: ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null,
        hasLearnMore: false,
        hasAnythingElse: false
    };
}

function combineDisplayResult(proposal : Recommendation, newInfo : SlotBag) {
    const { ctx, info:oldInfo } = proposal;
    if (!ctx)
        return null;
    const results = ctx.results;
    assert(results && results.length > 0);
    const topResult = results[0];
    assert(isInfoPhraseCompatibleWithResult(topResult, newInfo));

    const maybeNewInfo = oldInfo ? SlotBag.merge(oldInfo, newInfo) : newInfo;
    if (maybeNewInfo === null)
        return null;

    const newProposal : Recommendation = {
        ctx: proposal.ctx,
        topResult: proposal.topResult,
        info: maybeNewInfo,
        action: proposal.action,
        hasLearnMore: false,
        hasAnythingElse: proposal.hasAnythingElse,
    };
    return newProposal;
}

function makeRecommendationReply(ctx : ContextInfo, proposal : Recommendation) {
    const { topResult, action, hasLearnMore } = proposal;
    const options : AgentReplyOptions = {
        numResults: 1
    };
    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 : ContextInfo, proposal : Recommendation) {
    const { action, hasAnythingElse } = proposal;
    const options : AgentReplyOptions = {
        numResults: 1
    };
    if (action || hasAnythingElse)
        options.end = false;
    return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_display_result', null), proposal, null, options);
}

function negativeRecommendationReply(ctx : ContextInfo, [preamble, request] : [Ast.Expression|null, Ast.Expression|null]) {
    if (!((preamble === null || preamble instanceof Ast.FilterExpression) &&
          (request === null || request instanceof Ast.FilterExpression)))
        return null;

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

function positiveRecommendationReply(loader : ThingpediaLoader,
                                     ctx : ContextInfo,
                                     acceptedAction : Ast.Invocation|null,
                                     name : Ast.Value|null) {
    const proposal = ctx.aux as Recommendation;
    const { topResult, action: actionProposal } = proposal;

    // FIXME this should be allowed when we can parameter-pass by non-ID
    if (!topResult.value.id)
        return null;

    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;
    }
    assert(acceptedAction);

    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 (name) {
        const confirm = loader.ttUtils.normalizeConfirmAnnotation(acceptedAction.schema as Ast.FunctionDef);
        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 : ContextInfo, valid : boolean) {
    // 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 : ContextInfo, name : Ast.Value|null) {
    const proposal = ctx.aux as Recommendation;
    const { topResult, } = proposal;
    if (name !== null && (!topResult.value.id || !topResult.value.id.equals(name)))
        return null;
    return makeSimpleState(ctx, 'learn_more', null);
}

function repeatCommandReply(ctx : ContextInfo) {
    if (ctx.next)
        return null;
    if (ctx.currentFunction!.is_monitorable)
        return null;

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

export {
    makeActionRecommendation,
    makeArgMinMaxRecommendation,
    makeRecommendation,
    makeThingpediaRecommendation,
    makeAnswerStyleRecommendation,
    checkRecommendation,
    checkActionForRecommendation,
    makeDisplayResult,
    combineDisplayResult,
    makeRecommendationReply,
    makeDisplayResultReply,

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

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	import ThingpediaLoader from '../load-thingpedia';
28
29	import { SlotBag } from '../slot_bag';	2✔
30	import {	2✔
31	AgentReplyOptions,
32	ContextInfo,
33	makeAgentReply,
34	makeSimpleState,
35	addActionParam,
36	addNewItem,
37	} from '../state_manip';
38	import {	2✔
39	isInfoPhraseCompatibleWithResult,
40	findChainParam
41	} from './common';
42	import {	2✔
43	refineFilterToAnswerQuestionOrChangeFilter,
44	combinePreambleAndRequest,
45	proposalReply
46	} from './refinement-helpers';
47	import {	2✔
48	addSlotToBag,
49	} from './results';
50
51
52	export interface Recommendation {
53	ctx : ContextInfo;
54	topResult : Ast.DialogueHistoryResultItem;
55	info : SlotBag\|null;
56	action : Ast.Invocation\|null;
57	hasLearnMore : boolean;
58	hasAnythingElse : boolean;
59	}
60
61	export function recommendationKeyFn(rec : Recommendation) {	2✔
62	return {	13,167✔
63	functionName: rec.ctx.currentFunction!.qualifiedName
64	};
65	}
66
67	function makeActionRecommendation(ctx : ContextInfo, action : Ast.Invocation) {
68	assert(action instanceof Ast.Invocation);	41,365✔
69
70	const results = ctx.results;	41,365✔
71	assert(results && results.length > 0);	41,365✔
72	const currentStmt = ctx.current!.stmt;	41,365✔
73	const currentTable = currentStmt.expression;	41,365✔
74	const last = currentTable.last;	41,365✔
75	if (last instanceof Ast.SliceExpression && last.limit.toJS() !== 1)	41,365!
76	return null;	×
77
78	const topResult = results[0];	41,365✔
79	const id = topResult.value.id;	41,365✔
80	if (!id)	41,365✔
81	return null;	40,936✔
82
83	if (action.in_params.length !== 1)	429✔
84	return null;	390✔
85
86	for (const param of action.in_params) {	39✔
87	if (param.value.equals(id))	39!
88	return { ctx, topResult, info: null, action, hasLearnMore: false, hasAnythingElse: false };	×
89	}
90
91	return null;	39✔
92	}
93
94	function makeArgMinMaxRecommendation(ctx : ContextInfo, name : Ast.Value, base : Ast.Expression, param : C.ParamSlot, direction : 'asc'\|'desc') {
95	const resultInfo = ctx.resultInfo!;	30,413✔
96	if (!resultInfo.argMinMaxField)	30,413!
97	return null;	×
98	if (!C.isSameFunction(base.schema!, ctx.currentFunction!))	30,413!
99	return null;	×
100	if (!C.isSameFunction(param.schema, ctx.currentFunction!))	30,413✔
101	return null;	6,093✔
102	if (direction !== resultInfo.argMinMaxField[1] \|\|	24,320✔
103	param.name !== resultInfo.argMinMaxField[0])
104	return null;	24,269✔
105
106	return makeRecommendation(ctx, name);	51✔
107	}
108
109	function makeRecommendation(ctx : ContextInfo, name : Ast.Value) {
110	const results = ctx.results;	816✔
111	assert(results && results.length > 0);	816✔
112	const currentStmt = ctx.current!.stmt;	816✔
113	const currentTable = currentStmt.expression;	816✔
114	const last = currentTable.last;	816✔
115	if (last instanceof Ast.SliceExpression && last.limit.toJS() !== 1)	816✔
116	return null;	9✔
117
118	const topResult = results[0];	807✔
119	const id = topResult.value.id;	807✔
120
121	if (!id \|\| !id.equals(name))	807!
122	return null;	×
123
124	return {	807✔
125	ctx, topResult,
126	info: null,
127	action: ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null,	1,614!
128	hasLearnMore: false,
129	hasAnythingElse: false
130	};
131	}
132
133	function makeThingpediaRecommendation(ctx : ContextInfo, info : SlotBag) {
134	const results = ctx.results;	28,389✔
135	assert(results && results.length > 0);	28,389✔
136	const currentStmt = ctx.current!.stmt;	28,389✔
137	const currentTable = currentStmt.expression;	28,389✔
138	const last = currentTable.last;	28,389✔
139	if (last instanceof Ast.SliceExpression && last.limit.toJS() !== 1)	28,389✔
140	return null;	1✔
141
142	const topResult = results[0];	28,388✔
143	if (!isInfoPhraseCompatibleWithResult(topResult, info))	28,388✔
144	return null;	28,211✔
145
146	return {	177✔
147	ctx, topResult,
148	info,
149	action: ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null,	393✔
150	hasLearnMore: false,
151	hasAnythingElse: false
152	};
153	}
154
155	function checkRecommendation(rec : Recommendation, info : SlotBag) {
156	if (!isInfoPhraseCompatibleWithResult(rec.topResult, info))	119,163✔
157	return null;	107,939✔
158
159	// check that the filter uses the right set of parameters
160	const resultInfo = rec.ctx.resultInfo!;	11,224✔
161	if (resultInfo.projection !== null) {	11,224✔
162	// check that all projected names are present
163	for (const name of resultInfo.projection) {	782✔
164	if (!info.has(name))	957✔
165	return null;	428✔
166	}
167	}
168
169	return {	10,796✔
170	ctx: rec.ctx, topResult: rec.topResult,
171	info,
172	action: rec.action,
173	hasLearnMore: rec.hasLearnMore,
174	hasAnythingElse: rec.hasAnythingElse
175	};
176	}
177
178	function checkActionForRecommendation(rec : Recommendation, action : Ast.Invocation) {
179	if (!rec.topResult.value.id)	9,146✔
180	return null;	457✔
181	const resultType = rec.topResult.value.id.getType();	8,689✔
182
183	if (rec.action !== null) {	8,689!
184	if (!C.isSameFunction(rec.action.schema!, action.schema!))	×
185	return null;	×
186	}
187
188	if (!C.hasArgumentOfType(action, resultType))	8,689✔
189	return null;	2,806✔
190
191	return {	5,883✔
192	ctx: rec.ctx, topResult: rec.topResult,
193	info: rec.info,
194	action,
195	hasLearnMore: rec.hasLearnMore,
196	hasAnythingElse: rec.hasAnythingElse
197	};
198	}
199
200	// make a recommendation that looks like an answer, that is, "so and so is a ..."
201	function makeAnswerStyleRecommendation(rec : Recommendation, filter : C.FilterSlot) {
202	assert(C.isSameFunction(rec.ctx.currentFunction!, filter.schema));	192,333✔
203	const added = addSlotToBag(new SlotBag(rec.ctx.currentFunction), filter);	192,333✔
204	if (!added)	192,333✔
205	return null;	84,115✔
206
207	return checkRecommendation(rec, added[0]);	108,218✔
208	}
209
210	export function recommendationSetLearnMore(rec : Recommendation) {	2✔
211	return {	1,601✔
212	ctx: rec.ctx, topResult: rec.topResult,
213	info: rec.info,
214	// reset the action to null if the agent explicitly asks to "learn more"
215	action: null,
216	hasLearnMore: true,
217	hasAnythingElse: rec.hasAnythingElse
218	};
219	}
220
221	function makeDisplayResult(ctx : ContextInfo, info : SlotBag) {
222	const results = ctx.results;	13,478✔
223	assert(results && results.length > 0);	13,478✔
224	const topResult = results[0];	13,478✔
225
226	if (ctx.currentFunction!.is_list)	13,478✔
227	return null;	1,656✔
228	if (!C.isSameFunction(ctx.currentFunction!, info.schema!))	11,822!
229	return null;	×
230	if (!isInfoPhraseCompatibleWithResult(topResult, info))	11,822✔
231	return null;	11,539✔
232	return {	283✔
233	ctx, topResult,
234	info,
235	action: ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null,	575✔
236	hasLearnMore: false,
237	hasAnythingElse: false
238	};
239	}
240
241	function combineDisplayResult(proposal : Recommendation, newInfo : SlotBag) {
242	const { ctx, info:oldInfo } = proposal;	×
243	if (!ctx)	×
244	return null;	×
245	const results = ctx.results;	×
246	assert(results && results.length > 0);	×
247	const topResult = results[0];	×
248	assert(isInfoPhraseCompatibleWithResult(topResult, newInfo));	×
249
250	const maybeNewInfo = oldInfo ? SlotBag.merge(oldInfo, newInfo) : newInfo;	×
251	if (maybeNewInfo === null)	×
252	return null;	×
253
254	const newProposal : Recommendation = {	×
255	ctx: proposal.ctx,
256	topResult: proposal.topResult,
257	info: maybeNewInfo,
258	action: proposal.action,
259	hasLearnMore: false,
260	hasAnythingElse: proposal.hasAnythingElse,
261	};
262	return newProposal;	×
263	}
264
265	function makeRecommendationReply(ctx : ContextInfo, proposal : Recommendation) {
266	const { topResult, action, hasLearnMore } = proposal;	2,342✔
267	const options : AgentReplyOptions = {	2,342✔
268	numResults: 1
269	};
270	if (action \|\| hasLearnMore)	2,342✔
271	options.end = false;	561✔
272	if (action === null) {	2,342✔
273	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_recommend_one', null), proposal, null, options);	1,898✔
274	} else {
275	const chainParam = findChainParam(topResult, action);	444✔
276	if (!chainParam)	444!
277	return null;	×
278	return makeAgentReply(ctx, addActionParam(ctx, 'sys_recommend_one', action, chainParam, topResult.value.id, 'proposed'),	444✔
279	proposal, null, options);
280	}
281	}
282
283	function makeDisplayResultReply(ctx : ContextInfo, proposal : Recommendation) {
284	const { action, hasAnythingElse } = proposal;	136✔
285	const options : AgentReplyOptions = {	136✔
286	numResults: 1
287	};
288	if (action \|\| hasAnythingElse)	136!
289	options.end = false;	×
290	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_display_result', null), proposal, null, options);	136✔
291	}
292
293	function negativeRecommendationReply(ctx : ContextInfo, [preamble, request] : [Ast.Expression\|null, Ast.Expression\|null]) {
294	if (!((preamble === null \|\| preamble instanceof Ast.FilterExpression) &&	48,318!
295	(request === null \|\| request instanceof Ast.FilterExpression)))
296	return null;	×
297
298	const proposal = ctx.aux;	48,318✔
299	const { topResult, info, } = proposal;	48,318✔
300	const proposalType = topResult.value.id ? topResult.value.id.getType() : null;	48,318!
301	request = combinePreambleAndRequest(preamble, request, info, proposalType);	48,318✔
302	if (request === null)	48,318✔
303	return null;	37,260✔
304	return proposalReply(ctx, request, refineFilterToAnswerQuestionOrChangeFilter);	11,058✔
305	}
306
307	function positiveRecommendationReply(loader : ThingpediaLoader,
308	ctx : ContextInfo,
309	acceptedAction : Ast.Invocation\|null,
310	name : Ast.Value\|null) {
311	const proposal = ctx.aux as Recommendation;	395,898✔
312	const { topResult, action: actionProposal } = proposal;	395,898✔
313
314	// FIXME this should be allowed when we can parameter-pass by non-ID
315	if (!topResult.value.id)	395,898!
UNCOV 316	return null;	×
317
318	if (acceptedAction === null) {	395,898✔
319	// if the user did not give an action earlier, and no action
320	// was proposed by the agent right now, the flow is roughly
321	//
322	// U: hello i am looking for a restaurant
323	// A: how about the ... ?
324	// U: sure I like that
325	//
326	// this doesn't make much sense, so we don't want this flow
327	if (actionProposal === null)	391,535✔
328	return null;	293,077✔
329
330	acceptedAction = actionProposal;	98,458✔
331	}
332	assert(acceptedAction);	102,821✔
333
334	if (actionProposal !== null && !C.isSameFunction(actionProposal.schema!, acceptedAction.schema!))	102,821!
335	return null;	×
336	if (name !== null && !topResult.value.id.equals(name))	102,821✔
337	return null;	99,988✔
338
339	// do not consider a phrase of the form "play X" to be "accepting the action by name"
340	// if the action auto-confirms, because the user is likely playing something else
341	if (name) {	2,833✔
342	const confirm = loader.ttUtils.normalizeConfirmAnnotation(acceptedAction.schema as Ast.FunctionDef);	316✔
343	if (confirm === 'auto')	316!
344	return null;	316✔
345	}
346
347	const chainParam = findChainParam(topResult, acceptedAction);	2,517✔
348	if (!chainParam)	2,517✔
349	return null;	945✔
350	return addActionParam(ctx, 'execute', acceptedAction!, chainParam, topResult.value.id, 'accepted');	1,572✔
351	}
352
353	function recommendationCancelReply(ctx : ContextInfo, valid : boolean) {
354	// see dialogue.genie for the meaning of this boolean
355	if (!valid)	3,339✔
356	return null;	1,303✔
357
358	// "thank you" closes the dialogue
359	// we cannot close the dialogue if we have pending actions
360	if (ctx.next)	2,036✔
361	return null;	103✔
362	return makeSimpleState(ctx, 'cancel', null);	1,933✔
363	}
364
365	function recommendationLearnMoreReply(ctx : ContextInfo, name : Ast.Value\|null) {
366	const proposal = ctx.aux as Recommendation;	335,936✔
367	const { topResult, } = proposal;	335,936✔
368	if (name !== null && (!topResult.value.id \|\| !topResult.value.id.equals(name)))	335,936✔
369	return null;	331,796✔
370	return makeSimpleState(ctx, 'learn_more', null);	4,140✔
371	}
372
373	function repeatCommandReply(ctx : ContextInfo) {
374	if (ctx.next)	106!
375	return null;	×
376	if (ctx.currentFunction!.is_monitorable)	106!
377	return null;	106✔
378
379	const clone = ctx.current!.clone();	×
380	clone.results = null;	×
381	clone.confirm = 'accepted';	×
382	return addNewItem(ctx, 'execute', null, 'accepted', clone);	×
383	}
384
385	export {
386	makeActionRecommendation,	2✔
387	makeArgMinMaxRecommendation,	2✔
388	makeRecommendation,	2✔
389	makeThingpediaRecommendation,	2✔
390	makeAnswerStyleRecommendation,	2✔
391	checkRecommendation,	2✔
392	checkActionForRecommendation,	2✔
393	makeDisplayResult,	2✔
394	combineDisplayResult,	2✔
395	makeRecommendationReply,	2✔
396	makeDisplayResultReply,	2✔
397
398	positiveRecommendationReply,	2✔
399	negativeRecommendationReply,	2✔
400	recommendationCancelReply,	2✔
401	recommendationLearnMoreReply,	2✔
402	repeatCommandReply,	2✔
403	};

stanford-oval / genie-toolkit / 1657

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