1323

pending completion

Build # 1323

Build Type

Pull #348

travis-ci-com

Committed by

web-flow

Commit Message

Merge 008ebd613 into 3231d4a28

Pull Request Pull Request #348: Some fixes to dataset generation

Run Details

6920 of 12996 branches covered (53.25%)

Branch coverage included in aggregate %.

4 of 9 new or added lines in 4 files covered. (44.44%)

1 existing line in 1 file now uncovered.

15617 of 24840 relevant lines covered (62.87%)

1660915.67 hits per line

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

10.86

/languages/thingtalk/dialogue_acts/coref-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 Type = ThingTalk.Type;

const {
    addQuery,
} = require('../state_manip');
const {
    queryRefinement,
    refineFilterToAnswerQuestion,
} = require('./refinement-helpers');


function areQuestionsValidForContext(ctx, questions) {
    if (ctx.resultInfo.isAggregation)
        return null;

    const schema = ctx.currentFunctionSchema;

    // if the function only contains one parameter, do not generate projection for it
    if (Object.keys(schema.out).length === 1)
        return null;

    for (const [qname, qtype] of questions) {
        assert(typeof qname === 'string');
        assert(qtype === null || qtype instanceof Type);
        const arg = schema.getArgument(qname);
        if (!arg || arg.is_input)
            return false;
        if (qtype !== null && !arg.type.equals(qtype))
            return false;
    }
    return true;
}

function recommendationSearchQuestionReply(ctx, questions) {
    const proposal = ctx.aux;
    const { topResult, info, } = proposal;
    if (info !== null) {
        for (const [pname, ptype] of questions) {
            if (info.has(pname))
                return null;
            if (!info.schema.hasArgument(pname))
                return null;
            if (ptype !== null && !info.schema.getArgType(pname).equals(ptype))
                return null;
        }
    }

    if (!areQuestionsValidForContext(ctx, questions))
        return null;

    const currentTable = ctx.current.stmt.table;
    const newFilter = new Ast.BooleanExpression.Atom(null, 'id', '==', topResult.value.id);
    const newTable = queryRefinement(currentTable, newFilter, refineFilterToAnswerQuestion,
        questions.map(([qname, qtype]) => qname));
    if (newTable === null)
        return null;
    return addQuery(ctx, 'execute', newTable, 'accepted');
}

function learnMoreSearchQuestionReply(ctx, questions) {
    const topResult = ctx.results[0];
    if (!areQuestionsValidForContext(ctx, questions))
        return null;

    const currentTable = ctx.current.stmt.table;
    const newFilter = new Ast.BooleanExpression.Atom(null, 'id', '==', topResult.value.id);
    const newTable = queryRefinement(currentTable, newFilter, refineFilterToAnswerQuestion,
        questions.map(([qname, qtype]) => qname));
    if (newTable === null)
        return null;
    return addQuery(ctx, 'execute', newTable, 'accepted');
}

function displayResultSearchQuestionReply(ctx, questions) {
    if (!areQuestionsValidForContext(ctx, questions))
        return null;

    const currentTable = ctx.current.stmt.table;
    const newTable = queryRefinement(currentTable, null, refineFilterToAnswerQuestion,
        questions.map(([qname, qtype]) => qname));
    if (newTable === null)
        return null;
    return addQuery(ctx, 'execute', newTable, 'accepted');
}

function listProposalSearchQuestionReply(ctx, [name, questions]) {
    const proposal = ctx.aux;
    const [results, info] = proposal;

    if (name !== null) {
        let good = false;
        for (let result of results) {
            if (!result.value.id)
                continue;
            if (result.value.id.equals(name)) {
                good = true;
                break;
            }
        }
        if (!good)
            return null;
    }

    if (info !== null) {
        for (let [pname, type] of questions) {
            assert(typeof pname === 'string');
            if (info.has(pname))
                return null;
            if (!info.schema.hasArgument(pname))
                return null;
            if (type !== null && !info.schema.getArgType(pname).equals(type))
                return null;
        }
    }

    if (!areQuestionsValidForContext(ctx, questions))
        return null;

    const currentTable = ctx.current.stmt.table;
    let newTable;
    if (name !== null) {
        const newFilter = new Ast.BooleanExpression.Atom(null, 'id', '==', name);
        newTable = queryRefinement(currentTable, newFilter, refineFilterToAnswerQuestion,
            questions.map(([qname, qtype]) => qname));
    } else {
        newTable = queryRefinement(currentTable, null, null,
            questions.map(([qname, qtype]) => qname));
    }
    if (newTable === null)
        return null;

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

function corefConstant(ctx, base, param) {
    const previous = ctx.previousDomain;
    assert(previous);
    if (previous.results.results.length === 0)
        return null;
    const ctxStmt = previous.stmt;
    const ctxSchema = ctxStmt.table ? ctxStmt.table.schema : ctxStmt.actions[0].schema;
    if (!ctxSchema.class) // FIXME not sure how this happens...
        return null;
    if (ctxSchema.class.name !== base.schema.class.name)
        return null;
    const result = previous.results.results[0];
    if (!result.value[param.name])
        return null;
    return result.value[param.name];
}

module.exports = {
    recommendationSearchQuestionReply,
    displayResultSearchQuestionReply,
    learnMoreSearchQuestionReply,
    listProposalSearchQuestionReply,
    corefConstant
};

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	const Type = ThingTalk.Type;	3✔
27
28	const {
29	addQuery,
30	} = require('../state_manip');	3✔
31	const {
32	queryRefinement,
33	refineFilterToAnswerQuestion,
34	} = require('./refinement-helpers');	3✔
35
36
37	function areQuestionsValidForContext(ctx, questions) {
NEW 38	if (ctx.resultInfo.isAggregation)	×
NEW 39	return null;	×
40
UNCOV 41	const schema = ctx.currentFunctionSchema;	×
42
43	// if the function only contains one parameter, do not generate projection for it
44	if (Object.keys(schema.out).length === 1)	×
45	return null;	×
46
47	for (const [qname, qtype] of questions) {	×
48	assert(typeof qname === 'string');	×
49	assert(qtype === null \|\| qtype instanceof Type);	×
50	const arg = schema.getArgument(qname);	×
51	if (!arg \|\| arg.is_input)	×
52	return false;	×
53	if (qtype !== null && !arg.type.equals(qtype))	×
54	return false;	×
55	}
56	return true;	×
57	}
58
59	function recommendationSearchQuestionReply(ctx, questions) {
60	const proposal = ctx.aux;	×
61	const { topResult, info, } = proposal;	×
62	if (info !== null) {	×
63	for (const [pname, ptype] of questions) {	×
64	if (info.has(pname))	×
65	return null;	×
66	if (!info.schema.hasArgument(pname))	×
67	return null;	×
68	if (ptype !== null && !info.schema.getArgType(pname).equals(ptype))	×
69	return null;	×
70	}
71	}
72
73	if (!areQuestionsValidForContext(ctx, questions))	×
74	return null;	×
75
76	const currentTable = ctx.current.stmt.table;	×
77	const newFilter = new Ast.BooleanExpression.Atom(null, 'id', '==', topResult.value.id);	×
78	const newTable = queryRefinement(currentTable, newFilter, refineFilterToAnswerQuestion,	×
79	questions.map(([qname, qtype]) => qname));	×
80	if (newTable === null)	×
81	return null;	×
82	return addQuery(ctx, 'execute', newTable, 'accepted');	×
83	}
84
85	function learnMoreSearchQuestionReply(ctx, questions) {
86	const topResult = ctx.results[0];	×
87	if (!areQuestionsValidForContext(ctx, questions))	×
88	return null;	×
89
90	const currentTable = ctx.current.stmt.table;	×
91	const newFilter = new Ast.BooleanExpression.Atom(null, 'id', '==', topResult.value.id);	×
92	const newTable = queryRefinement(currentTable, newFilter, refineFilterToAnswerQuestion,	×
93	questions.map(([qname, qtype]) => qname));	×
94	if (newTable === null)	×
95	return null;	×
96	return addQuery(ctx, 'execute', newTable, 'accepted');	×
97	}
98
99	function displayResultSearchQuestionReply(ctx, questions) {
100	if (!areQuestionsValidForContext(ctx, questions))	×
101	return null;	×
102
103	const currentTable = ctx.current.stmt.table;	×
104	const newTable = queryRefinement(currentTable, null, refineFilterToAnswerQuestion,	×
105	questions.map(([qname, qtype]) => qname));	×
106	if (newTable === null)	×
107	return null;	×
108	return addQuery(ctx, 'execute', newTable, 'accepted');	×
109	}
110
111	function listProposalSearchQuestionReply(ctx, [name, questions]) {
112	const proposal = ctx.aux;	×
113	const [results, info] = proposal;	×
114
115	if (name !== null) {	×
116	let good = false;	×
117	for (let result of results) {	×
118	if (!result.value.id)	×
119	continue;	×
120	if (result.value.id.equals(name)) {	×
121	good = true;	×
122	break;	×
123	}
124	}
125	if (!good)	×
126	return null;	×
127	}
128
129	if (info !== null) {	×
130	for (let [pname, type] of questions) {	×
131	assert(typeof pname === 'string');	×
132	if (info.has(pname))	×
133	return null;	×
134	if (!info.schema.hasArgument(pname))	×
135	return null;	×
136	if (type !== null && !info.schema.getArgType(pname).equals(type))	×
137	return null;	×
138	}
139	}
140
141	if (!areQuestionsValidForContext(ctx, questions))	×
142	return null;	×
143
144	const currentTable = ctx.current.stmt.table;	×
145	let newTable;
146	if (name !== null) {	×
147	const newFilter = new Ast.BooleanExpression.Atom(null, 'id', '==', name);	×
148	newTable = queryRefinement(currentTable, newFilter, refineFilterToAnswerQuestion,	×
149	questions.map(([qname, qtype]) => qname));	×
150	} else {
151	newTable = queryRefinement(currentTable, null, null,	×
152	questions.map(([qname, qtype]) => qname));	×
153	}
154	if (newTable === null)	×
155	return null;	×
156
157	return addQuery(ctx, 'execute', newTable, 'accepted');	×
158	}
159
160	function corefConstant(ctx, base, param) {
161	const previous = ctx.previousDomain;	1,184✔
162	assert(previous);	1,184✔
163	if (previous.results.results.length === 0)	1,184!
164	return null;	×
165	const ctxStmt = previous.stmt;	1,184✔
166	const ctxSchema = ctxStmt.table ? ctxStmt.table.schema : ctxStmt.actions[0].schema;	1,184!
167	if (!ctxSchema.class) // FIXME not sure how this happens...	1,184!
168	return null;	×
169	if (ctxSchema.class.name !== base.schema.class.name)	1,184!
170	return null;	1,184✔
171	const result = previous.results.results[0];	×
172	if (!result.value[param.name])	×
173	return null;	×
174	return result.value[param.name];	×
175	}
176
177	module.exports = {	3✔
178	recommendationSearchQuestionReply,
179	displayResultSearchQuestionReply,
180	learnMoreSearchQuestionReply,
181	listProposalSearchQuestionReply,
182	corefConstant
183	};

stanford-oval / genie-toolkit / 1323

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