2014

pending completion

Build # 2014

Build Type

Pull #632

travis-ci-com

Committed by

web-flow

Commit Message

Merge d95c88f3d into 0b153da3b

Pull Request Pull Request #632: Listen audio if we expect some input from the user

Run Details

12394 of 26035 branches covered (47.61%)

Branch coverage included in aggregate %.

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

9 existing lines in 5 files now uncovered.

28870 of 48940 relevant lines covered (58.99%)

439106.56 hits per line

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

87.37

/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 type { ListProposal } from './list-proposal';

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) {
    // we don't offer actions during recommendations
    if (ctx.state.dialogueAct === 'notification')
        return null;
    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 instanceof Ast.ProjectionExpression && last.expression instanceof Ast.SliceExpression))
        && results.length !== 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 instanceof Ast.ProjectionExpression && last.expression instanceof Ast.SliceExpression))
        && results.length !== 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 instanceof Ast.ProjectionExpression && last.expression instanceof Ast.SliceExpression))
        && results.length !== 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) {
    // we don't offer actions during recommendations
    if (rec.ctx.state.dialogueAct === 'notification')
        return null;
    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
    };
}

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];

    // this can occur if there is more than one result for a single result query,
    // which can occur for IoT queries over multiple devices
    if (!isInfoPhraseCompatibleWithResult(topResult, newInfo))
        return null;

    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);
}

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

stanford-oval / genie-toolkit / 2014

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