1331

pending completion

Build # 1331

Build Type

Pull #355

travis-ci-com

Committed by

web-flow

Commit Message

Merge 6d549fc33 into 149eb09cd

Pull Request Pull Request #355: Last minute fixes

Run Details

6921 of 13031 branches covered (53.11%)

Branch coverage included in aggregate %.

13 of 23 new or added lines in 4 files covered. (56.52%)

22 existing lines in 5 files now uncovered.

15592 of 24860 relevant lines covered (62.72%)

1640185.09 hits per line

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

56.48

/languages/thingtalk/dialogue_acts/search-questions.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,
    addQuery,
    addQueryAndAction,
} = require('../state_manip');
const {
    queryRefinement,
    refineFilterToAnswerQuestion
} = require('./refinement-helpers');
const {
    isValidSearchQuestion,
    isSimpleFilterTable,
    addParametersFromContext
} = require('./common');

function isGoodSearchQuestion(ctx, questions) {
    if (!isValidSearchQuestion(ctx.current.stmt.table, questions))
        return false;

    const ctxFilterTable = C.findFilterTable(ctx.current.stmt.table);
    if (!ctxFilterTable)
        return false;
    for (let q of questions) {
        if (C.filterUsesParam(ctxFilterTable.filter, q))
            return false;
    }
    return true;
}

function checkFilterPairForDisjunctiveQuestion(ctx, f1, f2) {
    if (!ctx.currentFunctionSchema.is_list)
        return null;
    if (f1.name !== f2.name)
        return null;
    if (!f1.value.getType().equals(f2.value.getType()))
        return null;
    if (f1.value.equals(f2.value))
        return null;

    let good1 = false;
    let good2 = false;
    for (let result of ctx.results) {
        const value = result.value[f1.name];
        if (!value)
            return null;
        if (value.equals(f1.value))
            good1 = true;
        if (value.equals(f2.value))
            good2 = true;
        if (good1 && good2)
            break;
    }
    if (!good1 || !good2)
        return null;

    return [f1.name, f1.value.getType()];
}

function makeSearchQuestion(ctx, questions) {
    if (!isGoodSearchQuestion(ctx, questions))
        return null;

    if (questions.length === 0)
        return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_generic_search_question', null));

    if (questions.length === 1) {
        const type = ctx.current.stmt.table.schema.getArgument(questions[0]).type;
        return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_search_question', questions), null, type);
    }

    return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_search_question', questions));
}

/**
 * Check if the table filters on the parameters `questions` (effectively providing a constraint on question)
 */
function isQueryAnswerValidForQuestion(table, questions) {
    assert(Array.isArray(questions));
    let answersQuestion = false;
    table.visit(new class extends Ast.NodeVisitor {
        visitAtomBooleanExpression(atom) {
            if (questions.some((q) => q === atom.name))
                answersQuestion = true;
            return true;
        }
        visitDontCareBooleanExpression(atom) {
            if (questions.some((q) => q === atom.name))
                answersQuestion = true;
            return true;
        }
    });
    return answersQuestion;
}

function preciseSearchQuestionAnswer(ctx, [answerTable, answerAction]) {
    const questions = ctx.state.dialogueActParam;
    if (questions !== null && !isQueryAnswerValidForQuestion(answerTable, questions))
        return null;

    const answerFunctions = C.getFunctionNames(answerTable);
    if (answerFunctions.length !== 1)
        return null;
    if (answerFunctions[0] !== ctx.currentFunction)
        return null;
    const currentTable = ctx.current.stmt.table;
    if (!isValidSearchQuestion(currentTable, questions || []))
        return null;

    // TODO we need to push down the filter, if possible
    if (!isSimpleFilterTable(answerTable))
        return null;

    if (answerAction !== null) {
        const answerFunctions = C.getFunctionNames(answerAction);
        assert(answerFunctions.length === 1);
        assert(answerAction instanceof Ast.Invocation);
        if (ctx.nextFunction !== null) {
            if (answerFunctions[0] !== ctx.nextFunction)
                return null;

            // check that we don't fill the chain parameter through this path:
            // the chain parameter can only be filled if the agent shows the results
            for (let in_param of answerAction.in_params) {
                if (in_param.name === ctx.nextInfo.chainParameter &&
                    !ctx.nextInfo.chainParameterFilled)
                    return null;
            }

            answerAction = addParametersFromContext(answerAction, C.getInvocation(ctx.next));
        }
    }

    const newTable = queryRefinement(currentTable, answerTable.filter, refineFilterToAnswerQuestion);
    if (newTable === null)
        return null;
    if (answerAction !== null)
        return addQueryAndAction(ctx, 'execute', newTable, answerAction, 'accepted');
    else
        return addQuery(ctx, 'execute', newTable, 'accepted');
}


function impreciseSearchQuestionAnswer(ctx, answer) {
    const questions = ctx.state.dialogueActParam;
    if (questions === null || questions.length !== 1)
        return null;
    assert(Array.isArray(questions) && questions.length > 0);
    if (answer === 'dontcare') {
        answer = new Ast.BooleanExpression.DontCare(null, questions[0]);
    } else if (answer instanceof Ast.BooleanExpression) {
        let pname;
        if (answer.isAnd) {
            assert(answer.operands.length === 2 && answer.operands[0] instanceof Ast.BooleanExpression.Atom
                   && answer.operands[1] instanceof Ast.BooleanExpression.Atom);
            assert(answer.operands[0].name === answer.operands[1].name &&
                   answer.operands[0].value.getType().equals(answer.operands[1].value.getType()));
            pname = answer.operands[0].name;
        } else if (answer.isNot) {
            assert(answer.expr.isAtom || answer.expr.isDontCare);
            pname = answer.expr.name;
        } else {
            assert(answer.isAtom || answer.isDontCare);
            pname = answer.name;
        }
        if (!questions.some((q) => q === pname))
            return null;
    } else {
        assert(questions.length === 1);
        assert(answer instanceof Ast.Value);
        answer = C.makeFilter(new Ast.Value.VarRef(questions[0]), '==', answer);
        if (answer === null)
            return null;
    }

    assert(answer instanceof Ast.BooleanExpression);
    const currentTable = ctx.current.stmt.table;
    if (!C.checkFilter(currentTable, answer))
        return null;

    const newTable = queryRefinement(currentTable, answer, refineFilterToAnswerQuestion);
    if (newTable === null)
        return null;
    return addQuery(ctx, 'execute', newTable, 'accepted');
}

module.exports = {
    checkFilterPairForDisjunctiveQuestion,
    makeSearchQuestion,
    preciseSearchQuestionAnswer,
    impreciseSearchQuestionAnswer
};

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	addQuery,
33	addQueryAndAction,
34	} = require('../state_manip');	3✔
35	const {
36	queryRefinement,
37	refineFilterToAnswerQuestion
38	} = require('./refinement-helpers');	3✔
39	const {
40	isValidSearchQuestion,
41	isSimpleFilterTable,
42	addParametersFromContext
43	} = require('./common');	3✔
44
45	function isGoodSearchQuestion(ctx, questions) {
46	if (!isValidSearchQuestion(ctx.current.stmt.table, questions))	8,824✔
47	return false;	7,968✔
48
49	const ctxFilterTable = C.findFilterTable(ctx.current.stmt.table);	856✔
50	if (!ctxFilterTable)	856✔
51	return false;	448✔
52	for (let q of questions) {	408✔
53	if (C.filterUsesParam(ctxFilterTable.filter, q))	493✔
54	return false;	176✔
55	}
56	return true;	232✔
57	}
58
59	function checkFilterPairForDisjunctiveQuestion(ctx, f1, f2) {
60	if (!ctx.currentFunctionSchema.is_list)	×
61	return null;	×
62	if (f1.name !== f2.name)	×
63	return null;	×
64	if (!f1.value.getType().equals(f2.value.getType()))	×
65	return null;	×
66	if (f1.value.equals(f2.value))	×
67	return null;	×
68
69	let good1 = false;	×
70	let good2 = false;	×
71	for (let result of ctx.results) {	×
72	const value = result.value[f1.name];	×
73	if (!value)	×
74	return null;	×
75	if (value.equals(f1.value))	×
76	good1 = true;	×
77	if (value.equals(f2.value))	×
78	good2 = true;	×
79	if (good1 && good2)	×
80	break;	×
81	}
82	if (!good1 \|\| !good2)	×
83	return null;	×
84
85	return [f1.name, f1.value.getType()];	×
86	}
87
88	function makeSearchQuestion(ctx, questions) {
89	if (!isGoodSearchQuestion(ctx, questions))	8,824✔
90	return null;	8,592✔
91
92	if (questions.length === 0)	232!
93	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_generic_search_question', null));	×
94
95	if (questions.length === 1) {	232✔
96	const type = ctx.current.stmt.table.schema.getArgument(questions[0]).type;	190✔
97	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_search_question', questions), null, type);	190✔
98	}
99
100	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_search_question', questions));	42✔
101	}
102
103	/**
104	* Check if the table filters on the parameters `questions` (effectively providing a constraint on question)
105	*/
106	function isQueryAnswerValidForQuestion(table, questions) {
107	assert(Array.isArray(questions));	717,058✔
108	let answersQuestion = false;	717,058✔
109	table.visit(new class extends Ast.NodeVisitor {	717,058✔
110	visitAtomBooleanExpression(atom) {
111	if (questions.some((q) => q === atom.name))	897,487✔
112	answersQuestion = true;	87,602✔
113	return true;	778,733✔
114	}
115	visitDontCareBooleanExpression(atom) {
116	if (questions.some((q) => q === atom.name))	×
117	answersQuestion = true;	×
118	return true;	×
119	}
120	});
121	return answersQuestion;	717,058✔
122	}
123
124	function preciseSearchQuestionAnswer(ctx, [answerTable, answerAction]) {
125	const questions = ctx.state.dialogueActParam;	717,058✔
126	if (questions !== null && !isQueryAnswerValidForQuestion(answerTable, questions))	717,058✔
127	return null;	629,784✔
128
129	const answerFunctions = C.getFunctionNames(answerTable);	87,274✔
130	if (answerFunctions.length !== 1)	87,274!
131	return null;	×
132	if (answerFunctions[0] !== ctx.currentFunction)	87,274✔
133	return null;	75,645✔
134	const currentTable = ctx.current.stmt.table;	11,629✔
135	if (!isValidSearchQuestion(currentTable, questions \|\| []))	11,629!
136	return null;	×
137
138	// TODO we need to push down the filter, if possible
139	if (!isSimpleFilterTable(answerTable))	11,629!
140	return null;	×
141
142	if (answerAction !== null) {	11,629!
UNCOV 143	const answerFunctions = C.getFunctionNames(answerAction);	×
UNCOV 144	assert(answerFunctions.length === 1);	×
UNCOV 145	assert(answerAction instanceof Ast.Invocation);	×
UNCOV 146	if (ctx.nextFunction !== null) {	×
UNCOV 147	if (answerFunctions[0] !== ctx.nextFunction)	×
148	return null;	×
149
150	// check that we don't fill the chain parameter through this path:
151	// the chain parameter can only be filled if the agent shows the results
UNCOV 152	for (let in_param of answerAction.in_params) {	×
UNCOV 153	if (in_param.name === ctx.nextInfo.chainParameter &&	×
154	!ctx.nextInfo.chainParameterFilled)
UNCOV 155	return null;	×
156	}
157
158	answerAction = addParametersFromContext(answerAction, C.getInvocation(ctx.next));	×
159	}
160	}
161
162	const newTable = queryRefinement(currentTable, answerTable.filter, refineFilterToAnswerQuestion);	11,629✔
163	if (newTable === null)	11,629✔
164	return null;	8,556✔
165	if (answerAction !== null)	3,073!
UNCOV 166	return addQueryAndAction(ctx, 'execute', newTable, answerAction, 'accepted');	×
167	else
168	return addQuery(ctx, 'execute', newTable, 'accepted');	3,073✔
169	}
170
171
172	function impreciseSearchQuestionAnswer(ctx, answer) {
173	const questions = ctx.state.dialogueActParam;	484,341✔
174	if (questions === null \|\| questions.length !== 1)	484,341✔
175	return null;	76,999✔
176	assert(Array.isArray(questions) && questions.length > 0);	407,342✔
177	if (answer === 'dontcare') {	407,342✔
178	answer = new Ast.BooleanExpression.DontCare(null, questions[0]);	2,225✔
179	} else if (answer instanceof Ast.BooleanExpression) {	405,117✔
180	let pname;
181	if (answer.isAnd) {	187,617!
182	assert(answer.operands.length === 2 && answer.operands[0] instanceof Ast.BooleanExpression.Atom	×
183	&& answer.operands[1] instanceof Ast.BooleanExpression.Atom);
184	assert(answer.operands[0].name === answer.operands[1].name &&	×
185	answer.operands[0].value.getType().equals(answer.operands[1].value.getType()));
186	pname = answer.operands[0].name;	×
187	} else if (answer.isNot) {	187,617!
188	assert(answer.expr.isAtom \|\| answer.expr.isDontCare);	×
189	pname = answer.expr.name;	×
190	} else {
191	assert(answer.isAtom \|\| answer.isDontCare);	187,617✔
192	pname = answer.name;	187,617✔
193	}
194	if (!questions.some((q) => q === pname))	187,617✔
195	return null;	184,339✔
196	} else {
197	assert(questions.length === 1);	217,500✔
198	assert(answer instanceof Ast.Value);	217,500✔
199	answer = C.makeFilter(new Ast.Value.VarRef(questions[0]), '==', answer);	217,500✔
200	if (answer === null)	217,500✔
201	return null;	217,012✔
202	}
203
204	assert(answer instanceof Ast.BooleanExpression);	5,991✔
205	const currentTable = ctx.current.stmt.table;	5,991✔
206	if (!C.checkFilter(currentTable, answer))	5,991✔
207	return null;	1,501✔
208
209	const newTable = queryRefinement(currentTable, answer, refineFilterToAnswerQuestion);	4,490✔
210	if (newTable === null)	4,490✔
211	return null;	2,053✔
212	return addQuery(ctx, 'execute', newTable, 'accepted');	2,437✔
213	}
214
215	module.exports = {	3✔
216	checkFilterPairForDisjunctiveQuestion,
217	makeSearchQuestion,
218	preciseSearchQuestionAnswer,
219	impreciseSearchQuestionAnswer
220	};

stanford-oval / genie-toolkit / 1331

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