1254

pending completion

Build # 1254

Build Type

Pull #270

travis-ci-com

Committed by

web-flow

Commit Message

Merge a9b84ca9c into 13ff4e5cc

Pull Request Pull Request #270: More core changes to make the Thingpedia models work

Run Details

6619 of 12811 branches covered (51.67%)

Branch coverage included in aggregate %.

325 of 694 new or added lines in 31 files covered. (46.83%)

268 existing lines in 18 files now uncovered.

15174 of 24648 relevant lines covered (61.56%)

1482735.02 hits per line

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

53.51

/languages/thingtalk/dialogue_acts/refinement-helpers.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 {
    addQuery
} = require('../state_manip');
const {
    isFilterCompatibleWithInfo,
    isSimpleFilterTable
} = require('./common');

/**
 * Find the filter table in the context.
 *
 * Like findFilterTable, but if we don't have one, make it up right before the invocation.
 *
 * Returns [root, filterTable]
 */
function findOrMakeFilterTable(root) {
    let table = root;
    let holder = null;
    while (!table.isFilter) {
        if (table.isSequence ||
            table.isHistory ||
            table.isWindow ||
            table.isTimeSeries)
            throw new Error('NOT IMPLEMENTED');

        // do not touch these with filters
        if (table.isAggregation ||
            table.isVarRef ||
            table.isResultRef)
            return [null, null];

        // go inside these
        if (table.isSort ||
            table.isIndex ||
            table.isSlice ||
            table.isProjection ||
            table.isCompute ||
            table.isAlias) {
            holder = table;
            table = table.table;
            continue;
        }

        if (table.isJoin) {
            holder = table;
            // go right on join, always
            table = table.rhs;
            continue;
        }

        assert(table.isInvocation);
        // if we get here, there is no filter table at all
        // make up one
        const newFilterTable = new Ast.Table.Filter(null, table, Ast.BooleanExpression.True, table.schema);
        if (holder === null) {
            assert(table === root);
            return [newFilterTable, newFilterTable];
        } else if (holder.isJoin) {
            holder.rhs = newFilterTable;
            return [root, newFilterTable];
        } else {
            holder.table = newFilterTable;
            return [root, newFilterTable];
        }
    }

    return [root, table];
}


function setsIntersect(s1, s2) {
    for (let el of s1) {
        if (s2.has(el))
            return true;
    }
    return false;
}


function neutralizeIDFilter(ast) {
    // clone a filter and replace "id == ..." atoms with "true"

    if (ast.isNot)
        return new Ast.BooleanExpression.Not(null, neutralizeIDFilter(ast.expr));
    if (ast.isOr)
        return new Ast.BooleanExpression.Or(null, ast.operands.map(neutralizeIDFilter));
    if (ast.isAnd)
        return new Ast.BooleanExpression.And(null, ast.operands.map(neutralizeIDFilter));
    if (ast.isTrue || ast.isDontCare || ast.isFalse || ast.isCompute || ast.isExternal)
        return ast;

    assert(ast.isAtom);
    if (ast.name === 'id' && ast.operator === '==')
        return Ast.BooleanExpression.True;
    return ast;
}


function filterToNegatedSlots(filter) {
    filter = filter.optimize();
    let operands, slots = {};
    if (filter.isAnd)
        operands = filter.operands;
    else
        operands = [filter];

    for (let operand of operands) {
        if (!operand.isNot)
            continue;
        let atom = operand.expr;
        if (!atom.isAtom && !atom.isDontCare)
            continue;

        slots[atom.name] = operand;
    }

    return slots;
}

function filterToSlots(filter) {
    filter = filter.optimize();
    let operands, slots = {};
    if (filter.isAnd)
        operands = filter.operands;
    else
        operands = [filter];

    for (let operand of operands) {
        if (!operand.isAtom && !operand.isDontCare)
            continue;

        slots[operand.name] = operand;
    }

    return slots;
}

function queryRefinement(ctxTable, newFilter, refineFilter, newProjection) {
    let cloneTable = ctxTable.clone();

    let refinedFilter;
    if (newFilter !== null) {
        let filterTable;
        [cloneTable, filterTable] = findOrMakeFilterTable(cloneTable);
        //if (ctxFilterTable === null)
        //    return null;
        assert(filterTable.isFilter);

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

        refinedFilter = refineFilter(filterTable.filter, newFilter);
        if (refinedFilter === null)
            return null;

        filterTable.filter = refinedFilter;
    }

    if (newProjection) {
        // if we have a new projection, we remove the projection entirely and replace it
        // with the new one

        if (cloneTable.isProjection)
            cloneTable = cloneTable.table;
        // there should be no projection of projection (will be optimized)
        assert(!cloneTable.isProjection);

        // remove a compute table as well (top-level compute is a sort of projection)
        if (cloneTable.isCompute)
            cloneTable = cloneTable.table;

        // still no projection here...
        assert(!cloneTable.isProjection);

        cloneTable = new Ast.Table.Projection(null, cloneTable, newProjection,
            C.resolveProjection(newProjection, cloneTable.schema));
    } else {
        // otherwise, we remove all fields from the projection that were mentioned in the
        // filter

        let oldProjection;
        if (cloneTable.isProjection) {
            oldProjection = cloneTable.args;
            cloneTable = cloneTable.table;
        }
        // there should be no projection of projection (will be optimized)
        assert(!cloneTable.isProjection);

        if (oldProjection) {
            if (newFilter !== null)
                newProjection = oldProjection.filter((pname) => !C.filterUsesParam(refinedFilter, pname));

            // if we removed the projection of the compute field, remove the projection entirely
            if (cloneTable.isCompute) {
                assert(cloneTable.expression instanceof Ast.Value.Computation);
                let field = cloneTable.expression.op;
                if (!newProjection.includes(field))
                    cloneTable = cloneTable.table;

                // there should still be no projection of projection (will be optimized)
                assert(!cloneTable.isProjection);
            }

            // if the projection is now empty, we don't add
            // the projection will be empty if
            // 1. the user asks a question
            // 2. the agent answers that question
            // 3. the user now refines the search indicating they don't like that answer
            //
            // on the other hand, if
            // 1. the user asks a question (eg. asks for "address")
            // 2. the agent answers that question
            // 3. the user now refines the search changing a different parameter
            // we will keep the projection

            if (newProjection.length > 0) {
                cloneTable = new Ast.Table.Projection(null, cloneTable, newProjection,
                    C.resolveProjection(newProjection, cloneTable.schema));
            }
        }
    }

    return cloneTable;
}


function refineFilterToAnswerQuestion(ctxFilter, refinedFilter) {
    // this function is used when:
    // - the agent asks a search refinement question, and the user answers it
    // - the agent proposes something to refine the question
    //
    // the refinement is allowed only if the parameter was not mentioned before
    // furthermore, "id ==" filters are removed from the refined filter, so a user
    // can choose a restaurant for a while then change their mind

    function getParamsInFilter(filter) {
        let params = new Set;
        filter.visit(new class extends Ast.NodeVisitor {
            visitAtomBooleanExpression(atom) {
                if (atom.name === 'id' && atom.operator === '==')
                    return false;
                params.add(atom.name);
                return false;
            }
            visitDontCareBooleanExpression(atom) {
                params.add(atom.name);
                return false;
            }
            visitExternalBooleanExpression() {
                return false;
            }
        });
        return params;
    }
    if (setsIntersect(getParamsInFilter(ctxFilter),  getParamsInFilter(refinedFilter)))
        return null;

    const clone = neutralizeIDFilter(ctxFilter);
    return new Ast.BooleanExpression.And(null, [clone, refinedFilter]).optimize();
}


function refineFilterToAnswerQuestionOrChangeFilter(ctxFilter, refinedFilter) {
    // this function is used:
    // - the agent proposes something, and the user replies with a bunch of filters
    //   (e.g. "how about terun?" "nah i'm looking for something chinese")
    //
    // the refinement is allowed only if the parameter was not mentioned before
    // at most one parameter can be mentioned in the context, in which case it must be different
    //
    // the refinement contains all clauses which are not explicitly negated in the refinement,
    // plus all of the refinement
    // furthermore, "id ==" filters are removed from the refined filter, so a user
    // can choose a restaurant for a while then change their mind

    ctxFilter = ctxFilter.optimize();
    refinedFilter = refinedFilter.optimize();

    const ctxSlots = filterToSlots(ctxFilter);
    const refinedSlots = filterToSlots(refinedFilter);
    const negatedRefinedSlots = filterToNegatedSlots(refinedFilter);

    let changedParam = undefined;
    // slots in the context must not mentioned in the refinement, except at most one can, and
    // it must be different operator or value
    //
    // note that both positive and negative filters are killed by this check
    // so neither "I want X food" nor "I don't like X food" are acceptable when "food =~ X" was
    // already in the context
    for (let key in ctxSlots) {
        assert(ctxSlots[key].isAtom || ctxSlots[key].isDontCare);
        if (negatedRefinedSlots[key])
            return null;
        if (refinedSlots[key]) {
            // dont change opinion from a dontcare to a not dontcare
            if (ctxSlots[key].isDontCare)
                return null;

            if (refinedSlots[key].equals(ctxSlots[key]))
                return null;
            if (changedParam !== undefined)
                return null;
            changedParam = key;
        }
    }

    const newCtxClauses = [];
    for (let clause of (ctxFilter.isAnd ? ctxFilter.operands : [ctxFilter])) {
        if (clause.isAtom || clause.isDontCare) {
            if (refinedSlots[clause.name])
                continue;
        }
        newCtxClauses.push(neutralizeIDFilter(clause));
    }

    return new Ast.BooleanExpression.And(null, [...newCtxClauses, refinedFilter]).optimize();
}


function refineFilterToChangeFilter(ctxFilter, refinedFilter) {
    // this function is used:
    // - when the agent returned zero results, and the user
    //   must change the search
    // - when the agent makes a filter proposal, and the user says no I want something else
    //
    // the refinement is allowed only if no new parameters are introduced (all parameters were
    // mentioned before), and at least one parameter is different than before
    //
    // the resulting filter uses all the parameters in ctxFilter that are not mentioned
    // in refinedFilter, as well as all of refinedFilter

    ctxFilter = ctxFilter.optimize();
    refinedFilter = refinedFilter.optimize();

    const ctxSlots = filterToSlots(ctxFilter);
    const refinedSlots = filterToSlots(refinedFilter);
    // all slots in the context must be either not mentioned in the refinement, or changed
    for (let key in ctxSlots) {
        if (refinedSlots[key] && refinedSlots[key].equals(ctxSlots[key]))
            return null;
    }
    // all slots that are in the refinement must be mentioned in the context
    for (let key in refinedSlots) {
        if (!ctxSlots[key])
            return null;
    }

    const ctxClauses = (ctxFilter.isAnd ? ctxFilter.operands : [ctxFilter]).filter((clause) => {
        let good = true;
        clause.visit(new class extends Ast.NodeVisitor {
             visitExternalBooleanExpression() {
                // do not recurse
                // get rid of get-predicates in the context, regardless
                good = false;
                return false;
            }
            visitValue() {
                // do not recurse
                return false;
            }

            visitAtomBooleanExpression(atom) {
                good = good && !C.filterUsesParam(refinedFilter, atom.name);
                return true;
            }
            visitDontCareBooleanExpression(atom) {
                good = good && !C.filterUsesParam(refinedFilter, atom.name);
                return true;
            }
        });
        return good;
    });

    return new Ast.BooleanExpression.And(null, [...ctxClauses, refinedFilter]).optimize();
}

/**
 * User act: in response to any proposal from the agent (refined query, recommendation, list
 * proposal), the user replies with a search.
 */
function proposalReply(ctx, request, refinementFunction) {
    if (!C.isSameFunction(ctx.currentFunctionSchema, request.schema))
        return null;

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

    const currentTable = ctx.current.stmt.table;
    const newTable = queryRefinement(currentTable, request.filter, refinementFunction);
    if (newTable === null)
        return null;

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

function isValidNegativePreambleForInfo(info, preamble) {
    // the preamble must match the info provided
    // (and we will negate it later)
    return isFilterCompatibleWithInfo(info, preamble.filter);
}

function combinePreambleAndRequest(preamble, request, info, proposalType) {
    if (preamble !== null) {
        if (info === null || !isValidNegativePreambleForInfo(info, preamble))
            return null;
    }

    if (preamble !== null && request !== null) {
        if (!C.isSameFunction(preamble.schema, request.schema))
            return null;
        const refined = refineFilterToChangeFilter(preamble.filter, request.filter);
        if (refined === null)
            return null;

        // convert the preamble into a request by negating it, then add the new request
        request = new Ast.Table.Filter(null, request.table, new Ast.BooleanExpression.And(null, [
            new Ast.BooleanExpression.Not(null, preamble.filter),
            request.filter
        ]), request.schema);
    } else if (preamble !== null) {
        // convert the preamble into a request by negating it
        // shallow clone
        assert(preamble instanceof Ast.Table.Filter);
        request = new Ast.Table.Filter(null, preamble.table, preamble.filter, preamble.schema);
        request.filter = new Ast.BooleanExpression.Not(null, request.filter);
    }
    assert(request !== null);

    const idType = request.schema.getArgType('id');

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

    return request;
}

module.exports = {
    findOrMakeFilterTable,
    queryRefinement,
    refineFilterToAnswerQuestion,
    refineFilterToAnswerQuestionOrChangeFilter,
    refineFilterToChangeFilter,
    proposalReply,
    combinePreambleAndRequest
};

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	addQuery
31	} = require('../state_manip');	3✔
32	const {
33	isFilterCompatibleWithInfo,
34	isSimpleFilterTable
35	} = require('./common');	3✔
36
37	/**
38	* Find the filter table in the context.
39	*
40	* Like findFilterTable, but if we don't have one, make it up right before the invocation.
41	*
42	* Returns [root, filterTable]
43	*/
44	function findOrMakeFilterTable(root) {
45	let table = root;	93,228✔
46	let holder = null;	93,228✔
47	while (!table.isFilter) {	93,228✔
48	if (table.isSequence \|\|	2,997!
49	table.isHistory \|\|
50	table.isWindow \|\|
51	table.isTimeSeries)
52	throw new Error('NOT IMPLEMENTED');	×
53
54	// do not touch these with filters
55	if (table.isAggregation \|\|	2,997!
56	table.isVarRef \|\|
57	table.isResultRef)
58	return [null, null];	×
59
60	// go inside these
61	if (table.isSort \|\|	2,997✔
62	table.isIndex \|\|
63	table.isSlice \|\|
64	table.isProjection \|\|
65	table.isCompute \|\|
66	table.isAlias) {
67	holder = table;	1,850✔
68	table = table.table;	1,850✔
69	continue;	1,850✔
70	}
71
72	if (table.isJoin) {	1,147!
73	holder = table;	×
74	// go right on join, always
75	table = table.rhs;	×
76	continue;	×
77	}
78
79	assert(table.isInvocation);	1,147✔
80	// if we get here, there is no filter table at all
81	// make up one
82	const newFilterTable = new Ast.Table.Filter(null, table, Ast.BooleanExpression.True, table.schema);	1,147✔
83	if (holder === null) {	1,147✔
84	assert(table === root);	657✔
85	return [newFilterTable, newFilterTable];	657✔
86	} else if (holder.isJoin) {	490!
87	holder.rhs = newFilterTable;	×
88	return [root, newFilterTable];	×
89	} else {
90	holder.table = newFilterTable;	490✔
91	return [root, newFilterTable];	490✔
92	}
93	}
94
95	return [root, table];	92,081✔
96	}
97
98
99	function setsIntersect(s1, s2) {
100	for (let el of s1) {	73,516✔
101	if (s2.has(el))	118,118✔
102	return true;	37,111✔
103	}
104	return false;	36,405✔
105	}
106
107
108	function neutralizeIDFilter(ast) {
109	// clone a filter and replace "id == ..." atoms with "true"
110
111	if (ast.isNot)	75,124!
112	return new Ast.BooleanExpression.Not(null, neutralizeIDFilter(ast.expr));	×
113	if (ast.isOr)	75,124!
114	return new Ast.BooleanExpression.Or(null, ast.operands.map(neutralizeIDFilter));	×
115	if (ast.isAnd)	75,124✔
116	return new Ast.BooleanExpression.And(null, ast.operands.map(neutralizeIDFilter));	17,829✔
117	if (ast.isTrue \|\| ast.isDontCare \|\| ast.isFalse \|\| ast.isCompute \|\| ast.isExternal)	57,295✔
118	return ast;	17,809✔
119
120	assert(ast.isAtom);	39,486✔
121	if (ast.name === 'id' && ast.operator === '==')	39,486!
122	return Ast.BooleanExpression.True;	×
123	return ast;	39,486✔
124	}
125
126
127	function filterToNegatedSlots(filter) {
128	filter = filter.optimize();	×
129	let operands, slots = {};	×
130	if (filter.isAnd)	×
131	operands = filter.operands;	×
132	else
133	operands = [filter];	×
134
135	for (let operand of operands) {	×
136	if (!operand.isNot)	×
137	continue;	×
138	let atom = operand.expr;	×
139	if (!atom.isAtom && !atom.isDontCare)	×
140	continue;	×
141
142	slots[atom.name] = operand;	×
143	}
144
145	return slots;	×
146	}
147
148	function filterToSlots(filter) {
149	filter = filter.optimize();	242,174✔
150	let operands, slots = {};	242,174✔
151	if (filter.isAnd)	242,174✔
152	operands = filter.operands;	123,286✔
153	else
154	operands = [filter];	118,888✔
155
156	for (let operand of operands) {	242,174✔
157	if (!operand.isAtom && !operand.isDontCare)	377,771✔
158	continue;	395✔
159
160	slots[operand.name] = operand;	377,376✔
161	}
162
163	return slots;	242,174✔
164	}
165
166	function queryRefinement(ctxTable, newFilter, refineFilter, newProjection) {
167	let cloneTable = ctxTable.clone();	74,623✔
168
169	let refinedFilter;
170	if (newFilter !== null) {	74,623!
171	let filterTable;
172	[cloneTable, filterTable] = findOrMakeFilterTable(cloneTable);	74,623✔
173	//if (ctxFilterTable === null)
174	// return null;
175	assert(filterTable.isFilter);	74,623✔
176
177	// TODO we need to push down the filter, if possible
178	if (!isSimpleFilterTable(filterTable))	74,623!
179	return null;	×
180
181	refinedFilter = refineFilter(filterTable.filter, newFilter);	74,623✔
182	if (refinedFilter === null)	74,623✔
183	return null;	29,586✔
184
185	filterTable.filter = refinedFilter;	45,037✔
186	}
187
188	if (newProjection) {	45,037!
189	// if we have a new projection, we remove the projection entirely and replace it
190	// with the new one
191
192	if (cloneTable.isProjection)	×
193	cloneTable = cloneTable.table;	×
194	// there should be no projection of projection (will be optimized)
195	assert(!cloneTable.isProjection);	×
196
197	// remove a compute table as well (top-level compute is a sort of projection)
NEW 198	if (cloneTable.isCompute)	×
NEW 199	cloneTable = cloneTable.table;	×
200
201	// still no projection here...
NEW 202	assert(!cloneTable.isProjection);	×
203
UNCOV 204	cloneTable = new Ast.Table.Projection(null, cloneTable, newProjection,	×
205	C.resolveProjection(newProjection, cloneTable.schema));
206	} else {
207	// otherwise, we remove all fields from the projection that were mentioned in the
208	// filter
209
210	let oldProjection;
211	if (cloneTable.isProjection) {	45,037✔
212	oldProjection = cloneTable.args;	556✔
213	cloneTable = cloneTable.table;	556✔
214	}
215	// there should be no projection of projection (will be optimized)
216	assert(!cloneTable.isProjection);	45,037✔
217
218	if (oldProjection) {	45,037✔
219	if (newFilter !== null)	556!
220	newProjection = oldProjection.filter((pname) => !C.filterUsesParam(refinedFilter, pname));	693✔
221
222	// if we removed the projection of the compute field, remove the projection entirely
223	if (cloneTable.isCompute) {	556!
NEW 224	assert(cloneTable.expression instanceof Ast.Value.Computation);	×
NEW 225	let field = cloneTable.expression.op;	×
NEW 226	if (!newProjection.includes(field))	×
NEW 227	cloneTable = cloneTable.table;	×
228
229	// there should still be no projection of projection (will be optimized)
NEW 230	assert(!cloneTable.isProjection);	×
231	}
232
233	// if the projection is now empty, we don't add
234	// the projection will be empty if
235	// 1. the user asks a question
236	// 2. the agent answers that question
237	// 3. the user now refines the search indicating they don't like that answer
238	//
239	// on the other hand, if
240	// 1. the user asks a question (eg. asks for "address")
241	// 2. the agent answers that question
242	// 3. the user now refines the search changing a different parameter
243	// we will keep the projection
244
245	if (newProjection.length > 0) {	556✔
246	cloneTable = new Ast.Table.Projection(null, cloneTable, newProjection,	506✔
247	C.resolveProjection(newProjection, cloneTable.schema));
248	}
249	}
250	}
251
252	return cloneTable;	45,037✔
253	}
254
255
256	function refineFilterToAnswerQuestion(ctxFilter, refinedFilter) {
257	// this function is used when:
258	// - the agent asks a search refinement question, and the user answers it
259	// - the agent proposes something to refine the question
260	//
261	// the refinement is allowed only if the parameter was not mentioned before
262	// furthermore, "id ==" filters are removed from the refined filter, so a user
263	// can choose a restaurant for a while then change their mind
264
265	function getParamsInFilter(filter) {
266	let params = new Set;	147,032✔
267	filter.visit(new class extends Ast.NodeVisitor {	147,032✔
268	visitAtomBooleanExpression(atom) {
269	if (atom.name === 'id' && atom.operator === '==')	170,351!
270	return false;	×
271	params.add(atom.name);	170,351✔
272	return false;	170,351✔
273	}
274	visitDontCareBooleanExpression(atom) {
275	params.add(atom.name);	53,970✔
276	return false;	53,970✔
277	}
278	visitExternalBooleanExpression() {
279	return false;	×
280	}
281	});
282	return params;	147,032✔
283	}
284	if (setsIntersect(getParamsInFilter(ctxFilter), getParamsInFilter(refinedFilter)))	73,516✔
285	return null;	37,111✔
286
287	const clone = neutralizeIDFilter(ctxFilter);	36,405✔
288	return new Ast.BooleanExpression.And(null, [clone, refinedFilter]).optimize();	36,405✔
289	}
290
291
292	function refineFilterToAnswerQuestionOrChangeFilter(ctxFilter, refinedFilter) {
293	// this function is used:
294	// - the agent proposes something, and the user replies with a bunch of filters
295	// (e.g. "how about terun?" "nah i'm looking for something chinese")
296	//
297	// the refinement is allowed only if the parameter was not mentioned before
298	// at most one parameter can be mentioned in the context, in which case it must be different
299	//
300	// the refinement contains all clauses which are not explicitly negated in the refinement,
301	// plus all of the refinement
302	// furthermore, "id ==" filters are removed from the refined filter, so a user
303	// can choose a restaurant for a while then change their mind
304
305	ctxFilter = ctxFilter.optimize();	×
306	refinedFilter = refinedFilter.optimize();	×
307
308	const ctxSlots = filterToSlots(ctxFilter);	×
309	const refinedSlots = filterToSlots(refinedFilter);	×
310	const negatedRefinedSlots = filterToNegatedSlots(refinedFilter);	×
311
312	let changedParam = undefined;	×
313	// slots in the context must not mentioned in the refinement, except at most one can, and
314	// it must be different operator or value
315	//
316	// note that both positive and negative filters are killed by this check
317	// so neither "I want X food" nor "I don't like X food" are acceptable when "food =~ X" was
318	// already in the context
319	for (let key in ctxSlots) {	×
320	assert(ctxSlots[key].isAtom \|\| ctxSlots[key].isDontCare);	×
321	if (negatedRefinedSlots[key])	×
322	return null;	×
323	if (refinedSlots[key]) {	×
324	// dont change opinion from a dontcare to a not dontcare
325	if (ctxSlots[key].isDontCare)	×
326	return null;	×
327
328	if (refinedSlots[key].equals(ctxSlots[key]))	×
329	return null;	×
330	if (changedParam !== undefined)	×
331	return null;	×
332	changedParam = key;	×
333	}
334	}
335
336	const newCtxClauses = [];	×
337	for (let clause of (ctxFilter.isAnd ? ctxFilter.operands : [ctxFilter])) {	×
338	if (clause.isAtom \|\| clause.isDontCare) {	×
339	if (refinedSlots[clause.name])	×
340	continue;	×
341	}
342	newCtxClauses.push(neutralizeIDFilter(clause));	×
343	}
344
345	return new Ast.BooleanExpression.And(null, [...newCtxClauses, refinedFilter]).optimize();	×
346	}
347
348
349	function refineFilterToChangeFilter(ctxFilter, refinedFilter) {
350	// this function is used:
351	// - when the agent returned zero results, and the user
352	// must change the search
353	// - when the agent makes a filter proposal, and the user says no I want something else
354	//
355	// the refinement is allowed only if no new parameters are introduced (all parameters were
356	// mentioned before), and at least one parameter is different than before
357	//
358	// the resulting filter uses all the parameters in ctxFilter that are not mentioned
359	// in refinedFilter, as well as all of refinedFilter
360
361	ctxFilter = ctxFilter.optimize();	121,087✔
362	refinedFilter = refinedFilter.optimize();	121,087✔
363
364	const ctxSlots = filterToSlots(ctxFilter);	121,087✔
365	const refinedSlots = filterToSlots(refinedFilter);	121,087✔
366	// all slots in the context must be either not mentioned in the refinement, or changed
367	for (let key in ctxSlots) {	121,087✔
368	if (refinedSlots[key] && refinedSlots[key].equals(ctxSlots[key]))	204,964✔
369	return null;	13,912✔
370	}
371	// all slots that are in the refinement must be mentioned in the context
372	for (let key in refinedSlots) {	107,175✔
373	if (!ctxSlots[key])	117,130✔
374	return null;	73,177✔
375	}
376
377	const ctxClauses = (ctxFilter.isAnd ? ctxFilter.operands : [ctxFilter]).filter((clause) => {	33,998✔
378	let good = true;	64,282✔
379	clause.visit(new class extends Ast.NodeVisitor {	64,282✔
380	visitExternalBooleanExpression() {
381	// do not recurse
382	// get rid of get-predicates in the context, regardless
383	good = false;	×
384	return false;	×
385	}
386	visitValue() {
387	// do not recurse
388	return false;	62,915✔
389	}
390
391	visitAtomBooleanExpression(atom) {
392	good = good && !C.filterUsesParam(refinedFilter, atom.name);	62,915✔
393	return true;	62,915✔
394	}
395	visitDontCareBooleanExpression(atom) {
396	good = good && !C.filterUsesParam(refinedFilter, atom.name);	1,367✔
397	return true;	1,367✔
398	}
399	});
400	return good;	64,282✔
401	});
402
403	return new Ast.BooleanExpression.And(null, [...ctxClauses, refinedFilter]).optimize();	33,998✔
404	}
405
406	/**
407	* User act: in response to any proposal from the agent (refined query, recommendation, list
408	* proposal), the user replies with a search.
409	*/
410	function proposalReply(ctx, request, refinementFunction) {
411	if (!C.isSameFunction(ctx.currentFunctionSchema, request.schema))	13,307!
412	return null;	×
413
414	// TODO we need to push down the filter, if possible
415	if (!isSimpleFilterTable(request))	13,307!
416	return null;	×
417
418	const currentTable = ctx.current.stmt.table;	13,307✔
419	const newTable = queryRefinement(currentTable, request.filter, refinementFunction);	13,307✔
420	if (newTable === null)	13,307!
421	return null;	×
422
423	return addQuery(ctx, 'execute', newTable, 'accepted');	13,307✔
424	}
425
426	function isValidNegativePreambleForInfo(info, preamble) {
427	// the preamble must match the info provided
428	// (and we will negate it later)
429	return isFilterCompatibleWithInfo(info, preamble.filter);	×
430	}
431
432	function combinePreambleAndRequest(preamble, request, info, proposalType) {
433	if (preamble !== null) {	×
434	if (info === null \|\| !isValidNegativePreambleForInfo(info, preamble))	×
435	return null;	×
436	}
437
438	if (preamble !== null && request !== null) {	×
439	if (!C.isSameFunction(preamble.schema, request.schema))	×
440	return null;	×
441	const refined = refineFilterToChangeFilter(preamble.filter, request.filter);	×
442	if (refined === null)	×
443	return null;	×
444
445	// convert the preamble into a request by negating it, then add the new request
446	request = new Ast.Table.Filter(null, request.table, new Ast.BooleanExpression.And(null, [	×
447	new Ast.BooleanExpression.Not(null, preamble.filter),
448	request.filter
449	]), request.schema);
450	} else if (preamble !== null) {	×
451	// convert the preamble into a request by negating it
452	// shallow clone
453	assert(preamble instanceof Ast.Table.Filter);	×
454	request = new Ast.Table.Filter(null, preamble.table, preamble.filter, preamble.schema);	×
455	request.filter = new Ast.BooleanExpression.Not(null, request.filter);	×
456	}
457	assert(request !== null);	×
458
459	const idType = request.schema.getArgType('id');	×
460
461	if (!idType \|\| !idType.equals(proposalType))	×
462	return null;	×
463
464	return request;	×
465	}
466
467	module.exports = {	3✔
468	findOrMakeFilterTable,
469	queryRefinement,
470	refineFilterToAnswerQuestion,
471	refineFilterToAnswerQuestionOrChangeFilter,
472	refineFilterToChangeFilter,
473	proposalReply,
474	combinePreambleAndRequest
475	};

stanford-oval / genie-toolkit / 1254

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