1708

pending completion

Build # 1708

Build Type

Pull #502

travis-ci-com

Committed by

web-flow

Commit Message

Merge 34a9b6f86 into 059232071

Pull Request Pull Request #502: Another round of bug fixes

Run Details

10904 of 23360 branches covered (46.68%)

Branch coverage included in aggregate %.

22 of 29 new or added lines in 5 files covered. (75.86%)

104 existing lines in 7 files now uncovered.

25465 of 44001 relevant lines covered (57.87%)

544393.92 hits per line

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

85.9

/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();

    const currentStmt = ctx.current!.stmt;
    const currentTable = currentStmt.expression;
    const last = currentTable.last;
    if (last instanceof Ast.SliceExpression &&
        results.length !== ctx.results!.length)
        return null;

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

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

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

        // check that the filter uses the right set of parameters
        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 currentStmt = ctx.current!.stmt;
    const currentTable = currentStmt.expression;
    const last = currentTable.last;
    if (last instanceof Ast.SliceExpression &&
        results.length !== ctx.results!.length)
        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,343✔
59	return {	1,343✔
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 {	782✔
73	idType: results[0].value.id.getType(),
74	queryName: info ? info.schema!.qualifiedName : null,	782✔
75	actionName: action ? action.schema!.qualifiedName : null,	782✔
76	};
77	}
78
79	function checkListProposal(nameList : NameList, info : SlotBag\|null, hasLearnMore : boolean) : ListProposal\|null {
80	const { ctx, results } = nameList;	19,150✔
81	const resultType = results[0].value.id.getType();	19,150✔
82
83	const currentStmt = ctx.current!.stmt;	19,150✔
84	const currentTable = currentStmt.expression;	19,150✔
85	const last = currentTable.last;	19,150✔
86	if (last instanceof Ast.SliceExpression &&	19,150!
87	results.length !== ctx.results!.length)
NEW 88	return null;	×
89
90	if (info !== null) {	19,150✔
91	const idType = info.schema!.getArgType('id');	18,566✔
92
93	if (!idType \|\| !idType.equals(resultType))	18,566!
94	return null;	×
95
96	const resultInfo = ctx.resultInfo!;	18,566✔
97	if (resultInfo.projection !== null) {	18,566✔
98	// check that all projected names are present
99	for (const name of resultInfo.projection) {	40✔
100	if (!info.has(name))	40✔
101	return null;	16✔
102	}
103	}
104
105	// check that the filter uses the right set of parameters
106	for (const result of results) {	18,550✔
107	if (!isInfoPhraseCompatibleWithResult(result, info))	37,128✔
108	return null;	18,470✔
109	}
110	} else {
111	if (ctx.resultInfo!.projection !== null)	584✔
112	return null;	177✔
113	}
114
115
116	const action = ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null;	487!
117	return [results, info, action, hasLearnMore];	487✔
118	}
119
120	function addActionToListProposal(nameList : NameList, action : Ast.Invocation) : ListProposal\|null {
121	const { ctx, results } = nameList;	2,920✔
122	if (ctx.resultInfo!.projection !== null)	2,920✔
123	return null;	885✔
124
125	const currentStmt = ctx.current!.stmt;	2,035✔
126	const currentTable = currentStmt.expression;	2,035✔
127	const last = currentTable.last;	2,035✔
128	if (last instanceof Ast.SliceExpression &&	2,035!
129	results.length !== ctx.results!.length)
NEW 130	return null;	×
131
132	const resultType = results[0].value.id.getType();	2,035✔
133	if (!C.hasArgumentOfType(action, resultType))	2,035✔
134	return null;	1,740✔
135	const ctxAction = ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null;	295!
136	if (ctxAction && !C.isSameFunction(ctxAction.schema!, action.schema!))	295!
137	return null;	×
138
139	return [results, null, action, false];	295✔
140	}
141
142	function makeListProposalReply(ctx : ContextInfo, proposal : ListProposal) {
143	const [results, /info/, action, hasLearnMore] = proposal;	5,197✔
144	const options : AgentReplyOptions = {	5,197✔
145	numResults: results.length
146	};
147	if (action \|\| hasLearnMore)	5,197!
148	options.end = false;	5,197✔
149	const dialogueAct = results.length === 2 ? 'sys_recommend_two' : 'sys_recommend_three';	5,197✔
150	if (action === null)	5,197✔
151	return makeAgentReply(ctx, makeSimpleState(ctx, dialogueAct, null), proposal, null, options);	3,835✔
152	else
153	return makeAgentReply(ctx, addAction(ctx, dialogueAct, action, 'proposed'), proposal, null, options);	1,362✔
154	}
155
156	function positiveListProposalReply(loader : ThingpediaLoader,
157	ctx : ContextInfo,
158	[name, acceptedAction, mustHaveAction] : [Ast.Value, Ast.Invocation\|null, boolean]) {
159	// if actionProposal === null the flow is roughly
160	//
161	// U: hello i am looking for a restaurant
162	// A: how about the ... or the ... ?
163	// U: I like the ... bla
164	//
165	// in this case, the agent should hit the "... is a ... restaurant in the ..."
166	// we treat it as "execute" dialogue act and add a filter that causes the program to return a single result
167
168	const proposal = ctx.aux as ListProposal;	501,925✔
169	const [results, /info/, actionProposal] = proposal;	501,925✔
170	let good = false;	501,925✔
171	for (const result of results) {	501,925✔
172	if (result.value.id.equals(name)) {	1,191,069✔
173	good = true;	5,288✔
174	break;	5,288✔
175	}
176	}
177	if (!good)	501,925✔
178	return null;	496,637✔
179
180	if (acceptedAction === null)	5,288✔
181	acceptedAction = actionProposal;	5,230✔
182
183	if (acceptedAction === null) {	5,288✔
184	if (mustHaveAction)	4,969✔
185	return null;	2,595✔
186
187	const currentStmt = ctx.current!.stmt;	2,374✔
188	const currentTable = currentStmt.expression;	2,374✔
189	const namefilter = new Ast.BooleanExpression.Atom(null, 'id', '==', name);	2,374✔
190	const newTable = queryRefinement(currentTable, namefilter, (one, two) => new Ast.BooleanExpression.And(null, [one, two]), null);	2,374✔
191	if (newTable === null)	2,374!
192	return null;	×
193
194	return addQuery(ctx, 'execute', newTable, 'accepted');	2,374✔
195	} else {
196	if (actionProposal !== null && !C.isSameFunction(actionProposal.schema!, acceptedAction.schema!))	319!
197	return null;	×
198
199	// do not consider a phrase of the form "play X" to be "accepting the action by name"
200	// if the action auto-confirms, because the user is likely playing something else
201	if (acceptedAction && name) {	319!
202	const confirm = loader.ttUtils.normalizeConfirmAnnotation(acceptedAction.schema as Ast.FunctionDef);	319✔
203	if (confirm === 'auto')	319!
204	return null;	319✔
205	}
206
207	const chainParam = findChainParam(results[0], acceptedAction);	×
208	if (!chainParam)	×
209	return null;	×
210	return addActionParam(ctx, 'execute', acceptedAction, chainParam, name, 'accepted');	×
211	}
212	}
213
214	function positiveListProposalReplyActionByName(loader : ThingpediaLoader,
215	ctx : ContextInfo,
216	action : Ast.Invocation) {
217	const proposal = ctx.aux;	8,907✔
218	const [results,] = proposal;	8,907✔
219
220	let name = null;	8,907✔
221	const acceptedAction = action.clone();	8,907✔
222	const idType = results[0].value.id.getType();	8,907✔
223	// find the chain parameter for the action, extract the name, and set the param to undefined
224	// as the rest of the code expects
225	for (const in_param of acceptedAction.in_params) {	8,907✔
226	const arg = action.schema!.getArgument(in_param.name);	4,884✔
227	assert(arg);	4,884✔
228	if (arg.type.equals(idType)) {	4,884✔
229	name = in_param.value;	65✔
230	in_param.value = new Ast.Value.Undefined(true);	65✔
231	break;	65✔
232	}
233	}
234	if (!name)	8,907✔
235	return null;	8,842✔
236	return positiveListProposalReply(loader, ctx, [name, acceptedAction, false]);	65✔
237	}
238
239	function negativeListProposalReply(ctx : ContextInfo, [preamble, request] : [Ast.Expression\|null, Ast.Expression\|null]) {
240	if (!((preamble === null \|\| preamble instanceof Ast.FilterExpression) &&	35,523!
241	(request === null \|\| request instanceof Ast.FilterExpression)))
242	return null;	×
243
244	const proposal = ctx.aux as ListProposal;	35,523✔
245	const [results, info] = proposal;	35,523✔
246	const proposalType = results[0].value.id.getType();	35,523✔
247	request = combinePreambleAndRequest(preamble, request, info, proposalType);	35,523✔
248	if (request === null)	35,523✔
249	return null;	26,841✔
250	return proposalReply(ctx, request, refineFilterToAnswerQuestionOrChangeFilter);	8,682✔
251	}
252
253	function listProposalLearnMoreReply(ctx : ContextInfo, name : Ast.Value) {
254	// note: a learn more from a list proposal is different than a learn_more from a recommendation
255	// in a recommendation, there is no change to the program, and the agent replies "what would
256	// you like to know"
257	// in a list proposal, we add a filter "id == "
258
259	const proposal = ctx.aux as ListProposal;	265,185✔
260	const [results,] = proposal;	265,185✔
261	let good = false;	265,185✔
262	for (const result of results) {	265,185✔
263	if (result.value.id.equals(name)) {	644,311✔
264	good = true;	8,605✔
265	break;	8,605✔
266	}
267	}
268	if (!good)	265,185✔
269	return null;	256,580✔
270
271	const currentStmt = ctx.current!.stmt;	8,605✔
272	const currentTable = currentStmt.expression;	8,605✔
273	const namefilter = new Ast.BooleanExpression.Atom(null, 'id', '==', name);	8,605✔
274	const newTable = queryRefinement(currentTable, namefilter, (one, two) => new Ast.BooleanExpression.And(null, [one, two]), null);	8,605✔
275	if (newTable === null)	8,605!
276	return null;	×
277
278	return addQuery(ctx, 'execute', newTable, 'accepted');	8,605✔
279	}
280
281	export {
282	checkListProposal,	2✔
283	addActionToListProposal,	2✔
284	makeListProposalReply,	2✔
285
286	positiveListProposalReply,	2✔
287	positiveListProposalReplyActionByName,	2✔
288	listProposalLearnMoreReply,	2✔
289	negativeListProposalReply	2✔
290	};

stanford-oval / genie-toolkit / 1708

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