1244

pending completion

Build # 1244

Build Type

Pull #247

travis-ci-com

Committed by

web-flow

Commit Message

Merge d70937b29 into 64b94b170

Pull Request Pull Request #247: Add script to check how well synthetic set covers evaluation set

Run Details

6634 of 12712 branches covered (52.19%)

Branch coverage included in aggregate %.

13 of 62 new or added lines in 1 file covered. (20.97%)

13 existing lines in 2 files now uncovered.

15342 of 24487 relevant lines covered (62.65%)

1998136.24 hits per line

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

62.44

/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.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))	18,093✔
47	return false;	15,904✔
48
49	const ctxFilterTable = C.findFilterTable(ctx.current.stmt.table);	2,189✔
50	if (!ctxFilterTable)	2,189✔
51	return false;	596✔
52	for (let q of questions) {	1,593✔
53	if (C.filterUsesParam(ctxFilterTable.filter, q))	1,740✔
54	return false;	677✔
55	}
56	return true;	916✔
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))	18,093✔
90	return null;	17,177✔
91
92	if (questions.length === 0)	916!
93	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_generic_search_question', null));	×
94
95	if (questions.length === 1) {	916✔
96	const type = ctx.current.stmt.table.schema.getArgument(questions[0]).type;	836✔
97	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_search_question', questions), null, type);	836✔
98	}
99
100	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_search_question', questions));	80✔
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));	542,069✔
108	let answersQuestion = false;	542,069✔
109	table.visit(new class extends Ast.NodeVisitor {	542,069✔
110	visitAtomBooleanExpression(atom) {
111	if (questions.some((q) => q === atom.name))	671,510✔
112	answersQuestion = true;	59,785✔
113	return true;	633,052✔
114	}
115	visitDontCareBooleanExpression(atom) {
116	if (questions.some((q) => q === atom.name))	×
117	answersQuestion = true;	×
118	return true;	×
119	}
120	});
121	return answersQuestion;	542,069✔
122	}
123
124	function preciseSearchQuestionAnswer(ctx, [answerTable, answerAction]) {
125	const questions = ctx.state.dialogueActParam;	542,069✔
126	if (questions !== null && !isQueryAnswerValidForQuestion(answerTable, questions))	542,069✔
127	return null;	482,720✔
128
129	const answerFunctions = C.getFunctionNames(answerTable);	59,349✔
130	if (answerFunctions.length !== 1)	59,349!
131	return null;	×
132	if (answerFunctions[0] !== ctx.currentFunction)	59,349✔
133	return null;	53,168✔
134	const currentTable = ctx.current.stmt.table;	6,181✔
135	if (!isValidSearchQuestion(currentTable, questions \|\| []))	6,181!
136	return null;	×
137
138	// TODO we need to push down the filter, if possible
139	if (!isSimpleFilterTable(answerTable))	6,181!
140	return null;	×
141
142	if (answerAction !== null) {	6,181✔
143	const answerFunctions = C.getFunctionNames(answerAction);	5✔
144	assert(answerFunctions.length === 1);	5✔
145	assert(answerAction instanceof Ast.Invocation);	5✔
146	if (ctx.nextFunction !== null) {	5!
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);	6,181✔
163	if (newTable === null)	6,181✔
164	return null;	2,228✔
165	if (answerAction !== null)	3,953✔
166	return addQueryAndAction(ctx, 'execute', newTable, answerAction, 'accepted');	3✔
167	else
168	return addQuery(ctx, 'execute', newTable, 'accepted');	3,950✔
169	}
170
171
172	function impreciseSearchQuestionAnswer(ctx, answer) {
173	const questions = ctx.state.dialogueActParam;	374,068✔
174	if (questions === null \|\| questions.length !== 1)	374,068✔
175	return null;	23,137✔
176	assert(Array.isArray(questions) && questions.length > 0);	350,931✔
177	if (answer === 'dontcare') {	350,931✔
178	answer = new Ast.BooleanExpression.DontCare(null, questions[0]);	2,526✔
179	} else if (answer instanceof Ast.BooleanExpression) {	348,405✔
180	let pname;
181	if (answer.isNot) {	188,600!
182	assert(answer.expr.isAtom \|\| answer.expr.isDontCare);	×
183	pname = answer.expr.name;	×
184	} else {
185	assert(answer.isAtom \|\| answer.isDontCare);	188,600✔
186	pname = answer.name;	188,600✔
187	}
188	if (!questions.some((q) => q === pname))	188,600✔
189	return null;	186,543✔
190	} else {
191	assert(questions.length === 1);	159,805✔
192	assert(answer instanceof Ast.Value);	159,805✔
193	answer = C.makeFilter(new Ast.Value.VarRef(questions[0]), '==', answer);	159,805✔
194	if (answer === null)	159,805✔
195	return null;	158,893✔
196	}
197
198	assert(answer instanceof Ast.BooleanExpression);	5,495✔
199	const currentTable = ctx.current.stmt.table;	5,495✔
200	if (!C.checkFilter(currentTable, answer))	5,495✔
201	return null;	580✔
202
203	const newTable = queryRefinement(currentTable, answer, refineFilterToAnswerQuestion);	4,915✔
204	if (newTable === null)	4,915✔
205	return null;	368✔
206	return addQuery(ctx, 'execute', newTable, 'accepted');	4,547✔
207	}
208
209	module.exports = {	3✔
210	checkFilterPairForDisjunctiveQuestion,
211	makeSearchQuestion,
212	preciseSearchQuestionAnswer,
213	impreciseSearchQuestionAnswer
214	};

stanford-oval / genie-toolkit / 1244

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