1868

pending completion

Build # 1868

Build Type

Pull #555

travis-ci-com

Committed by

web-flow

Commit Message

Merge 1e321ba28 into 6cd52e4f4

Pull Request Pull Request #555: Wip/mehrad/updates

Run Details

11391 of 24796 branches covered (45.94%)

Branch coverage included in aggregate %.

10 of 10 new or added lines in 3 files covered. (100.0%)

2 existing lines in 2 files now uncovered.

26775 of 46846 relevant lines covered (57.16%)

406943.89 hits per line

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

87.02

/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|null) {
    if (info && !isInfoPhraseCompatibleWithResult(rec.topResult, info))
        return null;

    const resultInfo = rec.ctx.resultInfo!;
    if (resultInfo.projection !== null) {
        // check that all projected names are present
        for (const name of resultInfo.projection) {
            if (!((info && info.has(name)) || (rec.info && rec.info.has(name))))
                return null;
        }
    }

    const merged = info && rec.info ? SlotBag.merge(info, rec.info) : (info || rec.info);
    if (info && rec.info && !merged)
        return null;

    return {
        ctx: rec.ctx, topResult: rec.topResult,
        info: merged,
        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 checkDisplayResult(proposal : Recommendation|null) {
    if (!proposal)
        return null;

    const resultInfo = proposal.ctx.resultInfo!;
    if (resultInfo.projection !== null) {
        // check that all projected names are present
        for (const name of resultInfo.projection) {
            if (!proposal.info || !proposal.info.has(name))
                return null;
        }
    }

    return proposal;
}

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

stanford-oval / genie-toolkit / 1868

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