1635

pending completion

Build # 1635

Build Type

Pull #452

travis-ci-com

Committed by

web-flow

Commit Message

Merge e0a97f387 into 316836d40

Pull Request Pull Request #452: Restore detailed message when no device of a given type is configured

Run Details

10808 of 23248 branches covered (46.49%)

Branch coverage included in aggregate %.

16 of 24 new or added lines in 2 files covered. (66.67%)

8 existing lines in 4 files now uncovered.

25391 of 43947 relevant lines covered (57.78%)

545392.36 hits per line

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

84.69

/languages/thingtalk/dialogue_acts/list-proposal.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 {
    AgentReplyOptions,
    ContextInfo,
    makeAgentReply,
    makeSimpleState,
    addActionParam,
    addAction,
    addQuery,
} from '../state_manip';
import {
    isInfoPhraseCompatibleWithResult,
    findChainParam
} from './common';
import {
    queryRefinement,
    refineFilterToAnswerQuestionOrChangeFilter,
    combinePreambleAndRequest,
    proposalReply,
} from './refinement-helpers';
import {
    SlotBag
} from '../slot_bag';

export interface NameList {
    ctx : ContextInfo;
    results : Ast.DialogueHistoryResultItem[];
}

export function nameListKeyFn(list : NameList) {
    const schema = list.ctx.currentFunction!;
    return {
        functionName: schema.qualifiedName,
        idType: schema.getArgType('id')!,

        id0: list.ctx.key.id0,
        id1: list.ctx.key.id1,
        id2: list.ctx.key.id2,
    };
}

export type ListProposal = [Ast.DialogueHistoryResultItem[], SlotBag|null, Ast.Invocation|null, boolean];

export function listProposalKeyFn([results, info, action, hasLearnMore] : ListProposal) {
    return {
        idType: results[0].value.id.getType(),
        queryName: info ? info.schema!.qualifiedName : null,
        actionName: action ? action.schema!.qualifiedName : null,
    };
}

function checkListProposal(nameList : NameList, info : SlotBag|null, hasLearnMore : boolean) : ListProposal|null {
    const { ctx, results } = nameList;
    const resultType = results[0].value.id.getType();

    if (info !== null) {
        const idType = info.schema!.getArgType('id');

        if (!idType || !idType.equals(resultType))
            return null;

        // check that the filter uses the right set of parameters
        const resultInfo = 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;
            }
        }

        for (const result of results) {
            if (!isInfoPhraseCompatibleWithResult(result, info))
                return null;
        }
    } else {
        if (ctx.resultInfo!.projection !== null)
            return null;
    }


    const action = ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null;
    return [results, info, action, hasLearnMore];
}

function addActionToListProposal(nameList : NameList, action : Ast.Invocation) : ListProposal|null {
    const { ctx, results } = nameList;
    if (ctx.resultInfo!.projection !== null)
        return null;

    const resultType = results[0].value.id.getType();
    if (!C.hasArgumentOfType(action, resultType))
        return null;
    const ctxAction = ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null;
    if (ctxAction && !C.isSameFunction(ctxAction.schema!, action.schema!))
        return null;

    return [results, null, action, false];
}

function makeListProposalReply(ctx : ContextInfo, proposal : ListProposal) {
    const [results, /*info*/, action, hasLearnMore] = proposal;
    const options : AgentReplyOptions = {
        numResults: results.length
    };
    if (action || hasLearnMore)
        options.end = false;
    const dialogueAct = results.length === 2 ? 'sys_recommend_two' : 'sys_recommend_three';
    if (action === null)
        return makeAgentReply(ctx, makeSimpleState(ctx, dialogueAct, null), proposal, null, options);
    else
        return makeAgentReply(ctx, addAction(ctx, dialogueAct, action, 'proposed'), proposal, null, options);
}

function positiveListProposalReply(loader : ThingpediaLoader,
                                   ctx : ContextInfo,
                                   [name, acceptedAction, mustHaveAction] : [Ast.Value, Ast.Invocation|null, boolean]) {
    // if actionProposal === null the flow is roughly
    //
    // U: hello i am looking for a restaurant
    // A: how about the ... or the ... ?
    // U: I like the ... bla
    //
    // in this case, the agent should hit the "... is a ... restaurant in the ..."
    // we treat it as "execute" dialogue act and add a filter that causes the program to return a single result

    const proposal = ctx.aux as ListProposal;
    const [results, /*info*/, actionProposal] = proposal;
    let good = false;
    for (const result of results) {
        if (result.value.id.equals(name)) {
            good = true;
            break;
        }
    }
    if (!good)
        return null;

    if (acceptedAction === null)
        acceptedAction = actionProposal;

    if (acceptedAction === null) {
        if (mustHaveAction)
            return null;

        const currentStmt = ctx.current!.stmt;
        const currentTable = currentStmt.expression;
        const namefilter = new Ast.BooleanExpression.Atom(null, 'id', '==', name);
        const newTable = queryRefinement(currentTable, namefilter, (one, two) => new Ast.BooleanExpression.And(null, [one, two]), null);
        if (newTable === null)
            return null;

        return addQuery(ctx, 'execute', newTable, 'accepted');
    } else {
        if (actionProposal !== null && !C.isSameFunction(actionProposal.schema!, acceptedAction.schema!))
            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 = loader.ttUtils.normalizeConfirmAnnotation(acceptedAction.schema as Ast.FunctionDef);
            if (confirm === 'auto')
                return null;
        }

        const chainParam = findChainParam(results[0], acceptedAction);
        if (!chainParam)
            return null;
        return addActionParam(ctx, 'execute', acceptedAction, chainParam, name, 'accepted');
    }
}

function positiveListProposalReplyActionByName(loader : ThingpediaLoader,
                                               ctx : ContextInfo,
                                               action : Ast.Invocation) {
    const proposal = ctx.aux;
    const [results,] = proposal;

    let name = null;
    const acceptedAction = action.clone();
    const idType = results[0].value.id.getType();
    // find the chain parameter for the action, extract the name, and set the param to undefined
    // as the rest of the code expects
    for (const in_param of acceptedAction.in_params) {
        const arg = action.schema!.getArgument(in_param.name);
        assert(arg);
        if (arg.type.equals(idType)) {
            name = in_param.value;
            in_param.value = new Ast.Value.Undefined(true);
            break;
        }
    }
    if (!name)
        return null;
    return positiveListProposalReply(loader, ctx, [name, acceptedAction, false]);
}

function negativeListProposalReply(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 as ListProposal;
    const [results, info] = proposal;
    const proposalType = results[0].value.id.getType();
    request = combinePreambleAndRequest(preamble, request, info, proposalType);
    if (request === null)
        return null;
    return proposalReply(ctx, request, refineFilterToAnswerQuestionOrChangeFilter);
}

function listProposalLearnMoreReply(ctx : ContextInfo, name : Ast.Value) {
    // note: a learn more from a list proposal is different than a learn_more from a recommendation
    // in a recommendation, there is no change to the program, and the agent replies "what would
    // you like to know"
    // in a list proposal, we add a filter "id == "

    const proposal = ctx.aux as ListProposal;
    const [results,] = proposal;
    let good = false;
    for (const result of results) {
        if (result.value.id.equals(name)) {
            good = true;
            break;
        }
    }
    if (!good)
        return null;

    const currentStmt = ctx.current!.stmt;
    const currentTable = currentStmt.expression;
    const namefilter = new Ast.BooleanExpression.Atom(null, 'id', '==', name);
    const newTable = queryRefinement(currentTable, namefilter, (one, two) => new Ast.BooleanExpression.And(null, [one, two]), null);
    if (newTable === null)
        return null;

    return addQuery(ctx, 'execute', newTable, 'accepted');
}

export {
    checkListProposal,
    addActionToListProposal,
    makeListProposalReply,

    positiveListProposalReply,
    positiveListProposalReplyActionByName,
    listProposalLearnMoreReply,
    negativeListProposalReply
};

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 {	2✔
30	AgentReplyOptions,
31	ContextInfo,
32	makeAgentReply,
33	makeSimpleState,
34	addActionParam,
35	addAction,
36	addQuery,
37	} from '../state_manip';
38	import {	2✔
39	isInfoPhraseCompatibleWithResult,
40	findChainParam
41	} from './common';
42	import {	2✔
43	queryRefinement,
44	refineFilterToAnswerQuestionOrChangeFilter,
45	combinePreambleAndRequest,
46	proposalReply,
47	} from './refinement-helpers';
48	import {
49	SlotBag
50	} from '../slot_bag';
51
52	export interface NameList {
53	ctx : ContextInfo;
54	results : Ast.DialogueHistoryResultItem[];
55	}
56
57	export function nameListKeyFn(list : NameList) {	2✔
58	const schema = list.ctx.currentFunction!;	1,335✔
59	return {	1,335✔
60	functionName: schema.qualifiedName,
61	idType: schema.getArgType('id')!,
62
63	id0: list.ctx.key.id0,
64	id1: list.ctx.key.id1,
65	id2: list.ctx.key.id2,
66	};
67	}
68
69	export type ListProposal = [Ast.DialogueHistoryResultItem[], SlotBag\|null, Ast.Invocation\|null, boolean];
70
71	export function listProposalKeyFn([results, info, action, hasLearnMore] : ListProposal) {	2✔
72	return {	918✔
73	idType: results[0].value.id.getType(),
74	queryName: info ? info.schema!.qualifiedName : null,	918✔
75	actionName: action ? action.schema!.qualifiedName : null,	918✔
76	};
77	}
78
79	function checkListProposal(nameList : NameList, info : SlotBag\|null, hasLearnMore : boolean) : ListProposal\|null {
80	const { ctx, results } = nameList;	2,915✔
81	const resultType = results[0].value.id.getType();	2,915✔
82
83	if (info !== null) {	2,915✔
84	const idType = info.schema!.getArgType('id');	2,327✔
85
86	if (!idType \|\| !idType.equals(resultType))	2,327!
87	return null;	×
88
89	// check that the filter uses the right set of parameters
90	const resultInfo = ctx.resultInfo!;	2,327✔
91	if (resultInfo.projection !== null) {	2,327!
92	// check that all projected names are present
UNCOV 93	for (const name of resultInfo.projection) {	×
UNCOV 94	if (!info.has(name))	×
95	return null;	×
96	}
97	}
98
99	for (const result of results) {	2,327✔
100	if (!isInfoPhraseCompatibleWithResult(result, info))	4,771✔
101	return null;	2,037✔
102	}
103	} else {
104	if (ctx.resultInfo!.projection !== null)	588✔
105	return null;	130✔
106	}
107
108
109	const action = ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null;	748!
110	return [results, info, action, hasLearnMore];	748✔
111	}
112
113	function addActionToListProposal(nameList : NameList, action : Ast.Invocation) : ListProposal\|null {
114	const { ctx, results } = nameList;	2,940✔
115	if (ctx.resultInfo!.projection !== null)	2,940✔
116	return null;	650✔
117
118	const resultType = results[0].value.id.getType();	2,290✔
119	if (!C.hasArgumentOfType(action, resultType))	2,290✔
120	return null;	2,120✔
121	const ctxAction = ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null;	170!
122	if (ctxAction && !C.isSameFunction(ctxAction.schema!, action.schema!))	170!
123	return null;	×
124
125	return [results, null, action, false];	170✔
126	}
127
128	function makeListProposalReply(ctx : ContextInfo, proposal : ListProposal) {
129	const [results, /info/, action, hasLearnMore] = proposal;	4,926✔
130	const options : AgentReplyOptions = {	4,926✔
131	numResults: results.length
132	};
133	if (action \|\| hasLearnMore)	4,926!
134	options.end = false;	4,926✔
135	const dialogueAct = results.length === 2 ? 'sys_recommend_two' : 'sys_recommend_three';	4,926✔
136	if (action === null)	4,926✔
137	return makeAgentReply(ctx, makeSimpleState(ctx, dialogueAct, null), proposal, null, options);	4,005✔
138	else
139	return makeAgentReply(ctx, addAction(ctx, dialogueAct, action, 'proposed'), proposal, null, options);	921✔
140	}
141
142	function positiveListProposalReply(loader : ThingpediaLoader,
143	ctx : ContextInfo,
144	[name, acceptedAction, mustHaveAction] : [Ast.Value, Ast.Invocation\|null, boolean]) {
145	// if actionProposal === null the flow is roughly
146	//
147	// U: hello i am looking for a restaurant
148	// A: how about the ... or the ... ?
149	// U: I like the ... bla
150	//
151	// in this case, the agent should hit the "... is a ... restaurant in the ..."
152	// we treat it as "execute" dialogue act and add a filter that causes the program to return a single result
153
154	const proposal = ctx.aux as ListProposal;	455,805✔
155	const [results, /info/, actionProposal] = proposal;	455,805✔
156	let good = false;	455,805✔
157	for (const result of results) {	455,805✔
158	if (result.value.id.equals(name)) {	1,096,261✔
159	good = true;	6,420✔
160	break;	6,420✔
161	}
162	}
163	if (!good)	455,805✔
164	return null;	449,385✔
165
166	if (acceptedAction === null)	6,420✔
167	acceptedAction = actionProposal;	6,342✔
168
169	if (acceptedAction === null) {	6,420✔
170	if (mustHaveAction)	6,098✔
171	return null;	2,742✔
172
173	const currentStmt = ctx.current!.stmt;	3,356✔
174	const currentTable = currentStmt.expression;	3,356✔
175	const namefilter = new Ast.BooleanExpression.Atom(null, 'id', '==', name);	3,356✔
176	const newTable = queryRefinement(currentTable, namefilter, (one, two) => new Ast.BooleanExpression.And(null, [one, two]), null);	3,356✔
177	if (newTable === null)	3,356!
178	return null;	×
179
180	return addQuery(ctx, 'execute', newTable, 'accepted');	3,356✔
181	} else {
182	if (actionProposal !== null && !C.isSameFunction(actionProposal.schema!, acceptedAction.schema!))	322!
183	return null;	×
184
185	// do not consider a phrase of the form "play X" to be "accepting the action by name"
186	// if the action auto-confirms, because the user is likely playing something else
187	if (acceptedAction && name) {	322!
188	const confirm = loader.ttUtils.normalizeConfirmAnnotation(acceptedAction.schema as Ast.FunctionDef);	322✔
189	if (confirm === 'auto')	322!
190	return null;	322✔
191	}
192
193	const chainParam = findChainParam(results[0], acceptedAction);	×
194	if (!chainParam)	×
195	return null;	×
196	return addActionParam(ctx, 'execute', acceptedAction, chainParam, name, 'accepted');	×
197	}
198	}
199
200	function positiveListProposalReplyActionByName(loader : ThingpediaLoader,
201	ctx : ContextInfo,
202	action : Ast.Invocation) {
203	const proposal = ctx.aux;	10,066✔
204	const [results,] = proposal;	10,066✔
205
206	let name = null;	10,066✔
207	const acceptedAction = action.clone();	10,066✔
208	const idType = results[0].value.id.getType();	10,066✔
209	// find the chain parameter for the action, extract the name, and set the param to undefined
210	// as the rest of the code expects
211	for (const in_param of acceptedAction.in_params) {	10,066✔
212	const arg = action.schema!.getArgument(in_param.name);	3,987✔
213	assert(arg);	3,987✔
214	if (arg.type.equals(idType)) {	3,987✔
215	name = in_param.value;	89✔
216	in_param.value = new Ast.Value.Undefined(true);	89✔
217	break;	89✔
218	}
219	}
220	if (!name)	10,066✔
221	return null;	9,977✔
222	return positiveListProposalReply(loader, ctx, [name, acceptedAction, false]);	89✔
223	}
224
225	function negativeListProposalReply(ctx : ContextInfo, [preamble, request] : [Ast.Expression\|null, Ast.Expression\|null]) {
226	if (!((preamble === null \|\| preamble instanceof Ast.FilterExpression) &&	32,845!
227	(request === null \|\| request instanceof Ast.FilterExpression)))
228	return null;	×
229
230	const proposal = ctx.aux as ListProposal;	32,845✔
231	const [results, info] = proposal;	32,845✔
232	const proposalType = results[0].value.id.getType();	32,845✔
233	request = combinePreambleAndRequest(preamble, request, info, proposalType);	32,845✔
234	if (request === null)	32,845✔
235	return null;	24,666✔
236	return proposalReply(ctx, request, refineFilterToAnswerQuestionOrChangeFilter);	8,179✔
237	}
238
239	function listProposalLearnMoreReply(ctx : ContextInfo, name : Ast.Value) {
240	// note: a learn more from a list proposal is different than a learn_more from a recommendation
241	// in a recommendation, there is no change to the program, and the agent replies "what would
242	// you like to know"
243	// in a list proposal, we add a filter "id == "
244
245	const proposal = ctx.aux as ListProposal;	273,004✔
246	const [results,] = proposal;	273,004✔
247	let good = false;	273,004✔
248	for (const result of results) {	273,004✔
249	if (result.value.id.equals(name)) {	648,107✔
250	good = true;	9,604✔
251	break;	9,604✔
252	}
253	}
254	if (!good)	273,004✔
255	return null;	263,400✔
256
257	const currentStmt = ctx.current!.stmt;	9,604✔
258	const currentTable = currentStmt.expression;	9,604✔
259	const namefilter = new Ast.BooleanExpression.Atom(null, 'id', '==', name);	9,604✔
260	const newTable = queryRefinement(currentTable, namefilter, (one, two) => new Ast.BooleanExpression.And(null, [one, two]), null);	9,604✔
261	if (newTable === null)	9,604!
262	return null;	×
263
264	return addQuery(ctx, 'execute', newTable, 'accepted');	9,604✔
265	}
266
267	export {
268	checkListProposal,	2✔
269	addActionToListProposal,	2✔
270	makeListProposalReply,	2✔
271
272	positiveListProposalReply,	2✔
273	positiveListProposalReplyActionByName,	2✔
274	listProposalLearnMoreReply,	2✔
275	negativeListProposalReply	2✔
276	};

stanford-oval / genie-toolkit / 1635

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