1084

pending completion

Build # 1084

Build Type

Pull #248

travis-ci-com

Committed by

web-flow

Commit Message

Merge 5faf0aca9 into 6245195ee

Pull Request Pull Request #248: Prototype for evaluate-by-device

Run Details

6750 of 12284 branches covered (54.95%)

Branch coverage included in aggregate %.

81 of 101 new or added lines in 3 files covered. (80.2%)

21 existing lines in 7 files now uncovered.

15410 of 23838 relevant lines covered (64.64%)

2821933.22 hits per line

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

86.08

/languages/thingtalk/dialogue_acts/list-proposal.js

// -*- mode: js; 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>
"use strict";

const assert = require('assert');

const ThingTalk = require('thingtalk');
const Ast = ThingTalk.Ast;

const C = require('../ast_manip');

const {
    makeAgentReply,
    makeSimpleState,
    addActionParam,
    addAction,
    addQuery,
} = require('../state_manip');
const {
    isInfoPhraseCompatibleWithResult,
    findChainParam
} = require('./common');
const {
    queryRefinement,
    refineFilterToAnswerQuestionOrChangeFilter,
    combinePreambleAndRequest,
    proposalReply,
} = require('./refinement-helpers');

function checkListProposal(nameList, info, hasLearnMore) {
    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;

        for (let 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, action) {
    const { ctx, results } = nameList;
    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, proposal) {
    const [results, /*info*/, action, hasLearnMore] = proposal;
    const options = {};
    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(ctx, [name, acceptedAction, mustHaveAction]) {
    // 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;
    const [results, /*info*/, actionProposal] = proposal;
    let good = false;
    for (let 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 currentTable = ctx.current.stmt.table;
        const namefilter = new Ast.BooleanExpression.Atom(null, 'id', '==', name);
        const newTable = queryRefinement(currentTable, namefilter, (one, two) => new Ast.BooleanExpression.And(null, [one, two]));
        if (newTable === null)
            return null;

        return addQuery(ctx, 'execute', newTable, 'accepted');
    } else {
        if (actionProposal !== null && !C.isSameFunction(actionProposal.schema, acceptedAction.schema))
            return null;

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

function positiveListProposalReplyActionByName(ctx, action) {
    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 (let 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;
        }
    }
    return positiveListProposalReply(ctx, [name, acceptedAction]);
}

function negativeListProposalReply(ctx, [preamble, request]) {
    const proposal = ctx.aux;
    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, name) {
    // 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;
    const [results,] = proposal;
    let good = false;
    for (let result of results) {
        if (result.value.id.equals(name)) {
            good = true;
            break;
        }
    }
    if (!good)
        return null;

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

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

module.exports = {
    checkListProposal,
    addActionToListProposal,
    makeListProposalReply,

    positiveListProposalReply,
    positiveListProposalReplyActionByName,
    listProposalLearnMoreReply,
    negativeListProposalReply
};

1	// -- mode: js; 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	"use strict";
21
22	const assert = require('assert');	3✔
23
24	const ThingTalk = require('thingtalk');	3✔
25	const Ast = ThingTalk.Ast;	3✔
26
27	const C = require('../ast_manip');	3✔
28
29	const {
30	makeAgentReply,
31	makeSimpleState,
32	addActionParam,
33	addAction,
34	addQuery,
35	} = require('../state_manip');	3✔
36	const {
37	isInfoPhraseCompatibleWithResult,
38	findChainParam
39	} = require('./common');	3✔
40	const {
41	queryRefinement,
42	refineFilterToAnswerQuestionOrChangeFilter,
43	combinePreambleAndRequest,
44	proposalReply,
45	} = require('./refinement-helpers');	3✔
46
47	function checkListProposal(nameList, info, hasLearnMore) {
48	const { ctx, results } = nameList;	15,679✔
49	const resultType = results[0].value.id.getType();	15,679✔
50
51	if (info !== null) {	15,679✔
52	const idType = info.schema.getArgType('id');	15,618✔
53
54	if (!idType \|\| !idType.equals(resultType))	15,618!
55	return null;	×
56
57	for (let result of results) {	15,618✔
58	if (!isInfoPhraseCompatibleWithResult(result, info))	22,230✔
59	return null;	15,168✔
60	}
61	} else {
62	if (ctx.resultInfo.projection !== null)	61!
63	return null;	×
64	}
65
66	const action = ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next) : null;	511✔
67	return [results, info, action, hasLearnMore];	511✔
68	}
69
70	function addActionToListProposal(nameList, action) {
71	const { ctx, results } = nameList;	360✔
72	const resultType = results[0].value.id.getType();	360✔
73	if (!C.hasArgumentOfType(action, resultType))	360✔
74	return null;	256✔
75	const ctxAction = ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next) : null;	104✔
76	if (ctxAction && !C.isSameFunction(ctxAction.schema, action.schema))	104!
77	return null;	×
78
79	return [results, null, action, false];	104✔
80	}
81
82	function makeListProposalReply(ctx, proposal) {
83	const [results, /info/, action, hasLearnMore] = proposal;	512✔
84	const options = {};	512✔
85	if (action \|\| hasLearnMore)	512!
86	options.end = false;	512✔
87	const dialogueAct = results.length === 2 ? 'sys_recommend_two' : 'sys_recommend_three';	512✔
88	if (action === null)	512✔
89	return makeAgentReply(ctx, makeSimpleState(ctx, dialogueAct, null), proposal, null, options);	505✔
90	else
91	return makeAgentReply(ctx, addAction(ctx, dialogueAct, action, 'proposed'), proposal, null, options);	7✔
92	}
93
94	function positiveListProposalReply(ctx, [name, acceptedAction, mustHaveAction]) {
95	// if actionProposal === null the flow is roughly
96	//
97	// U: hello i am looking for a restaurant
98	// A: how about the ... or the ... ?
99	// U: I like the ... bla
100	//
101	// in this case, the agent should hit the "... is a ... restaurant in the ..."
102	// we treat it as "execute" dialogue act and add a filter that causes the program to return a single result
103
104	const proposal = ctx.aux;	6,513✔
105	const [results, /info/, actionProposal] = proposal;	6,513✔
106	let good = false;	6,513✔
107	for (let result of results) {	6,513✔
108	if (result.value.id.equals(name)) {	12,895✔
109	good = true;	132✔
110	break;	132✔
111	}
112	}
113	if (!good)	6,513✔
114	return null;	6,381✔
115
116	if (acceptedAction === null)	132✔
117	acceptedAction = actionProposal;	129✔
118
119	if (acceptedAction === null) {	132✔
120	if (mustHaveAction)	27!
121	return null;	27✔
122
123	const currentTable = ctx.current.stmt.table;	×
124	const namefilter = new Ast.BooleanExpression.Atom(null, 'id', '==', name);	×
125	const newTable = queryRefinement(currentTable, namefilter, (one, two) => new Ast.BooleanExpression.And(null, [one, two]));	×
126	if (newTable === null)	×
127	return null;	×
128
129	return addQuery(ctx, 'execute', newTable, 'accepted');	×
130	} else {
131	if (actionProposal !== null && !C.isSameFunction(actionProposal.schema, acceptedAction.schema))	105✔
132	return null;	2✔
133
134	const chainParam = findChainParam(results[0], acceptedAction);	103✔
135	if (!chainParam)	103✔
136	return null;	1✔
137	return addActionParam(ctx, 'execute', acceptedAction, chainParam, name, 'accepted');	102✔
138	}
139	}
140
141	function positiveListProposalReplyActionByName(ctx, action) {
142	const proposal = ctx.aux;	112✔
143	const [results,] = proposal;	112✔
144
145	let name = null;	112✔
146	const acceptedAction = action.clone();	112✔
147	const idType = results[0].value.id.getType();	112✔
148	// find the chain parameter for the action, extract the name, and set the param to undefined
149	// as the rest of the code expects
150	for (let in_param of acceptedAction.in_params) {	112✔
151	const arg = action.schema.getArgument(in_param.name);	448✔
152	assert(arg);	448✔
153	if (arg.type.equals(idType)) {	448!
UNCOV 154	name = in_param.value;	×
UNCOV 155	in_param.value = new Ast.Value.Undefined(true);	×
UNCOV 156	break;	×
157	}
158	}
159	return positiveListProposalReply(ctx, [name, acceptedAction]);	112✔
160	}
161
162	function negativeListProposalReply(ctx, [preamble, request]) {
163	const proposal = ctx.aux;	287,167✔
164	const [results, info] = proposal;	287,167✔
165	const proposalType = results[0].value.id.getType();	287,167✔
166	request = combinePreambleAndRequest(preamble, request, info, proposalType);	287,167✔
167	if (request === null)	287,167✔
168	return null;	269,746✔
169	return proposalReply(ctx, request, refineFilterToAnswerQuestionOrChangeFilter);	17,421✔
170	}
171
172	function listProposalLearnMoreReply(ctx, name) {
173	// note: a learn more from a list proposal is different than a learn_more from a recommendation
174	// in a recommendation, there is no change to the program, and the agent replies "what would
175	// you like to know"
176	// in a list proposal, we add a filter "id == "
177
178	const proposal = ctx.aux;	650✔
179	const [results,] = proposal;	650✔
180	let good = false;	650✔
181	for (let result of results) {	650✔
182	if (result.value.id.equals(name)) {	1,282✔
183	good = true;	20✔
184	break;	20✔
185	}
186	}
187	if (!good)	650✔
188	return null;	630✔
189
190	const currentTable = ctx.current.stmt.table;	20✔
191	const namefilter = new Ast.BooleanExpression.Atom(null, 'id', '==', name);	20✔
192	const newTable = queryRefinement(currentTable, namefilter, (one, two) => new Ast.BooleanExpression.And(null, [one, two]));	20✔
193	if (newTable === null)	20!
194	return null;	×
195
196	return addQuery(ctx, 'execute', newTable, 'accepted');	20✔
197	}
198
199	module.exports = {	3✔
200	checkListProposal,
201	addActionToListProposal,
202	makeListProposalReply,
203
204	positiveListProposalReply,
205	positiveListProposalReplyActionByName,
206	listProposalLearnMoreReply,
207	negativeListProposalReply
208	};

stanford-oval / genie-toolkit / 1084

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