2344

pending completion

Build # 2344

Build Type

Pull #776

travis-ci-com

Committed by

web-flow

Commit Message

Merge c22e8702e into 6ab831361

Pull Request Pull Request #776: Fix NLG related issues

Run Details

10324 of 20884 branches covered (49.43%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 1 file covered. (100.0%)

29 existing lines in 9 files now uncovered.

23940 of 40095 relevant lines covered (59.71%)

343632.68 hits per line

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

92.21

/lib/templates/dialogue_acts/slot-fill.ts

// -*- mode: typescript; 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>


import assert from 'assert';

import { Ast, Type } from 'thingtalk';

import * as C from '../ast_manip';

import {
    ContextInfo,
    makeAgentReply,
    makeSimpleState,
    mergeParameters,
    setOrAddInvocationParam,
    addNewItem,
} from '../state_manip';


function isGoodSlotFillQuestion(ctx : ContextInfo, questions : C.ParamSlot[]) {
    const action = C.getInvocation(ctx.next!);
    assert(action instanceof Ast.Invocation);
    for (const q of questions) {
        if (!C.isSameFunction(q.schema, action.schema!))
            return false;
        if (q.name === ctx.nextInfo!.chainParameter)
            return false;
        const arg = action.schema!.getArgument(q.name);
        if (!arg || !arg.is_input)
            return false;
        for (const in_param of action.in_params) {
            if (in_param.name === q.name && !in_param.value.isUndefined)
                return false;
        }
    }
    return true;
}

function useRawModeForSlotFill(arg : Ast.ArgumentDef) {
    // raw mode bypasses _all_ natural language understanding
    // it is used to take in free-form inputs like messages or titles

    const type = arg.type;
    if (!type.isString)
        return false;

    // if the developer specified what to do for the argument, it is authoritative
    const annotation = arg.getAnnotation<boolean>('raw_mode');
    if (annotation !== undefined)
        return annotation;

    // use raw mode for free-form text parameters
    const stringvalues = arg.getAnnotation<string>('string_values');
    if (!stringvalues)
        return false;
    return ['tt:short_free_text', 'tt:long_free_text'].includes(stringvalues);
}


function makeSlotFillQuestion(ctx : ContextInfo, questions : C.ParamSlot[]) {
    if (!isGoodSlotFillQuestion(ctx, questions))
        return null;

    assert(questions.length > 0);
    if (questions.length === 1) {
        const action = C.getInvocation(ctx.next!);
        assert(action instanceof Ast.Invocation);
        const arg = action.schema!.getArgument(questions[0].name)!;
        const type = arg.type;

        const raw = useRawModeForSlotFill(arg);
        return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_slot_fill', questions.map((q) => q.name)), null, type, { raw });
    }
    return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_slot_fill', questions.map((q) => q.name)));
}

/**
 * Check if the action has parameters for the `questions`
 */
function isSlotFillAnswerValidForQuestion(action : Ast.Invocation, questions : string[]) {
    assert(Array.isArray(questions));
    assert(action instanceof Ast.Invocation);
    return questions.every((question) => {
        for (const in_param of action.in_params) {
            if (in_param.name === question)
                return !in_param.value.isUndefined;
        }
        return false;
    });
}

function fastSemiShallowClone(item : Ast.DialogueHistoryItem) {
    const newExpressions = [];
    const oldExpressions = item.stmt.expression.expressions;
    for (let i = 0; i < oldExpressions.length-1; i++)
        newExpressions.push(oldExpressions[i]);
    // deep clone only the last expression
    newExpressions.push(oldExpressions[oldExpressions.length-1].clone());
    const newStmt = new Ast.ExpressionStatement(null,
        new Ast.ChainExpression(null, newExpressions, item.stmt.expression.schema));

    return new Ast.DialogueHistoryItem(null, newStmt, null, 'accepted');
}

function preciseSlotFillAnswer(ctx : ContextInfo, answer : Ast.Invocation) {
    const questions = ctx.state.dialogueActParam as string[];
    assert(Array.isArray(questions) && questions.length > 0 && questions.every((q) => typeof q === 'string'));
    if (!isSlotFillAnswerValidForQuestion(answer, questions))
        return null;
    if (!C.isSameFunction(answer.schema!, ctx.nextFunction!))
        return null;
    assert(answer instanceof Ast.Invocation);
    assert(ctx.next && ctx.nextInfo);

    // 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 (const in_param of answer.in_params) {
        if (in_param.name === ctx.nextInfo.chainParameter &&
            !ctx.nextInfo.chainParameterFilled)
            return null;
    }

    const clone = fastSemiShallowClone(ctx.next);
    const newInvocation = C.getInvocation(clone);
    assert(newInvocation instanceof Ast.Invocation);
    assert(C.isSameFunction(newInvocation.schema!, answer.schema!));
    // modify in place
    mergeParameters(newInvocation, answer);

    return addNewItem(ctx, 'execute', null, 'accepted', clone);
}

function impreciseSlotFillAnswer(ctx : ContextInfo, answer : Ast.Value|C.InputParamSlot) {
    const questions = ctx.state.dialogueActParam as string[];
    assert(Array.isArray(questions) && questions.length > 0 && questions.every((q) => typeof q === 'string'));
    if (questions.length !== 1)
        return null;

    let ipslot : C.InputParamSlot;
    if (answer instanceof Ast.Value) {
        assert(questions.length === 1);

        const ptype = ctx.nextFunction!.getArgType(questions[0])!;
        if (!Type.isAssignable(answer.getType(), ptype, {}, ctx.loader.entitySubTypeMap))
            return null;
        ipslot = {
            schema: ctx.nextFunction!,
            ptype: ptype,
            ast: new Ast.InputParam(null, questions[0], answer)
        };
    } else {
        ipslot = answer;
        if (!questions.some((q) => q === ipslot.ast.name))
            return null;
        if (!C.isSameFunction(answer.schema, ctx.nextFunction!))
            return null;
    }

    assert(ctx.next && ctx.nextInfo);
    if (ipslot.ast.name === ctx.nextInfo.chainParameter)
        return null;

    const clone = fastSemiShallowClone(ctx.next);
    const newAction = C.getInvocation(clone);
    assert(newAction instanceof Ast.Invocation);
    if (!C.checkInvocationInputParam(ctx.loader, newAction, ipslot))
        return null;

    // modify in place
    setOrAddInvocationParam(newAction, ipslot.ast.name, ipslot.ast.value);
    return addNewItem(ctx, 'execute', null, 'accepted', clone);
}

export {
    makeSlotFillQuestion,

    preciseSlotFillAnswer,
    impreciseSlotFillAnswer
};

1	// -- mode: typescript; 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
21
22	import assert from 'assert';	97✔
23
24	import { Ast, Type } from 'thingtalk';	97✔
25
26	import * as C from '../ast_manip';	97✔
27
28	import {	97✔
29	ContextInfo,
30	makeAgentReply,
31	makeSimpleState,
32	mergeParameters,
33	setOrAddInvocationParam,
34	addNewItem,
35	} from '../state_manip';
36
37
38	function isGoodSlotFillQuestion(ctx : ContextInfo, questions : C.ParamSlot[]) {
39	const action = C.getInvocation(ctx.next!);	13,521✔
40	assert(action instanceof Ast.Invocation);	13,521✔
41	for (const q of questions) {	13,521✔
42	if (!C.isSameFunction(q.schema, action.schema!))	13,739✔
43	return false;	12,820✔
44	if (q.name === ctx.nextInfo!.chainParameter)	919✔
45	return false;	22✔
46	const arg = action.schema!.getArgument(q.name);	897✔
47	if (!arg \|\| !arg.is_input)	897!
48	return false;	×
49	for (const in_param of action.in_params) {	897✔
50	if (in_param.name === q.name && !in_param.value.isUndefined)	2,061✔
51	return false;	353✔
52	}
53	}
54	return true;	326✔
55	}
56
57	function useRawModeForSlotFill(arg : Ast.ArgumentDef) {
58	// raw mode bypasses _all_ natural language understanding
59	// it is used to take in free-form inputs like messages or titles
60
61	const type = arg.type;	206✔
62	if (!type.isString)	206✔
63	return false;	143✔
64
65	// if the developer specified what to do for the argument, it is authoritative
66	const annotation = arg.getAnnotation<boolean>('raw_mode');	63✔
67	if (annotation !== undefined)	63!
68	return annotation;	×
69
70	// use raw mode for free-form text parameters
71	const stringvalues = arg.getAnnotation<string>('string_values');	63✔
72	if (!stringvalues)	63!
UNCOV 73	return false;	×
74	return ['tt:short_free_text', 'tt:long_free_text'].includes(stringvalues);	63✔
75	}
76
77
78	function makeSlotFillQuestion(ctx : ContextInfo, questions : C.ParamSlot[]) {
79	if (!isGoodSlotFillQuestion(ctx, questions))	13,521✔
80	return null;	13,195✔
81
82	assert(questions.length > 0);	326✔
83	if (questions.length === 1) {	326✔
84	const action = C.getInvocation(ctx.next!);	206✔
85	assert(action instanceof Ast.Invocation);	206✔
86	const arg = action.schema!.getArgument(questions[0].name)!;	206✔
87	const type = arg.type;	206✔
88
89	const raw = useRawModeForSlotFill(arg);	206✔
90	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_slot_fill', questions.map((q) => q.name)), null, type, { raw });	206✔
91	}
92	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_slot_fill', questions.map((q) => q.name)));	240✔
93	}
94
95	/**
96	* Check if the action has parameters for the `questions`
97	*/
98	function isSlotFillAnswerValidForQuestion(action : Ast.Invocation, questions : string[]) {
99	assert(Array.isArray(questions));	25,893✔
100	assert(action instanceof Ast.Invocation);	25,893✔
101	return questions.every((question) => {	25,893✔
102	for (const in_param of action.in_params) {	26,869✔
103	if (in_param.name === question)	31,750✔
104	return !in_param.value.isUndefined;	26,360✔
105	}
106	return false;	509✔
107	});
108	}
109
110	function fastSemiShallowClone(item : Ast.DialogueHistoryItem) {
111	const newExpressions = [];	24,065✔
112	const oldExpressions = item.stmt.expression.expressions;	24,065✔
113	for (let i = 0; i < oldExpressions.length-1; i++)	24,065✔
114	newExpressions.push(oldExpressions[i]);	13,935✔
115	// deep clone only the last expression
116	newExpressions.push(oldExpressions[oldExpressions.length-1].clone());	24,065✔
117	const newStmt = new Ast.ExpressionStatement(null,	24,065✔
118	new Ast.ChainExpression(null, newExpressions, item.stmt.expression.schema));
119
120	return new Ast.DialogueHistoryItem(null, newStmt, null, 'accepted');	24,065✔
121	}
122
123	function preciseSlotFillAnswer(ctx : ContextInfo, answer : Ast.Invocation) {
124	const questions = ctx.state.dialogueActParam as string[];	25,893✔
125	assert(Array.isArray(questions) && questions.length > 0 && questions.every((q) => typeof q === 'string'));	27,865✔
126	if (!isSlotFillAnswerValidForQuestion(answer, questions))	25,893✔
127	return null;	10,320✔
128	if (!C.isSameFunction(answer.schema!, ctx.nextFunction!))	15,573!
129	return null;	×
130	assert(answer instanceof Ast.Invocation);	15,573✔
131	assert(ctx.next && ctx.nextInfo);	15,573✔
132
133	// check that we don't fill the chain parameter through this path:
134	// the chain parameter can only be filled if the agent shows the results
135	for (const in_param of answer.in_params) {	15,573✔
136	if (in_param.name === ctx.nextInfo.chainParameter &&	17,467!
137	!ctx.nextInfo.chainParameterFilled)
138	return null;	×
139	}
140
141	const clone = fastSemiShallowClone(ctx.next);	15,573✔
142	const newInvocation = C.getInvocation(clone);	15,573✔
143	assert(newInvocation instanceof Ast.Invocation);	15,573✔
144	assert(C.isSameFunction(newInvocation.schema!, answer.schema!));	15,573✔
145	// modify in place
146	mergeParameters(newInvocation, answer);	15,573✔
147
148	return addNewItem(ctx, 'execute', null, 'accepted', clone);	15,573✔
149	}
150
151	function impreciseSlotFillAnswer(ctx : ContextInfo, answer : Ast.Value\|C.InputParamSlot) {
152	const questions = ctx.state.dialogueActParam as string[];	165,548✔
153	assert(Array.isArray(questions) && questions.length > 0 && questions.every((q) => typeof q === 'string'));	186,207✔
154	if (questions.length !== 1)	165,548✔
155	return null;	20,659✔
156
157	let ipslot : C.InputParamSlot;
158	if (answer instanceof Ast.Value) {	144,889✔
159	assert(questions.length === 1);	69,357✔
160
161	const ptype = ctx.nextFunction!.getArgType(questions[0])!;	69,357✔
162	if (!Type.isAssignable(answer.getType(), ptype, {}, ctx.loader.entitySubTypeMap))	69,357✔
163	return null;	61,465✔
164	ipslot = {	7,892✔
165	schema: ctx.nextFunction!,
166	ptype: ptype,
167	ast: new Ast.InputParam(null, questions[0], answer)
168	};
169	} else {
170	ipslot = answer;	75,532✔
171	if (!questions.some((q) => q === ipslot.ast.name))	75,532✔
172	return null;	74,913✔
173	if (!C.isSameFunction(answer.schema, ctx.nextFunction!))	619✔
174	return null;	19✔
175	}
176
177	assert(ctx.next && ctx.nextInfo);	8,492✔
178	if (ipslot.ast.name === ctx.nextInfo.chainParameter)	8,492!
179	return null;	×
180
181	const clone = fastSemiShallowClone(ctx.next);	8,492✔
182	const newAction = C.getInvocation(clone);	8,492✔
183	assert(newAction instanceof Ast.Invocation);	8,492✔
184	if (!C.checkInvocationInputParam(ctx.loader, newAction, ipslot))	8,492✔
185	return null;	7,632✔
186
187	// modify in place
188	setOrAddInvocationParam(newAction, ipslot.ast.name, ipslot.ast.value);	860✔
189	return addNewItem(ctx, 'execute', null, 'accepted', clone);	860✔
190	}
191
192	export {
193	makeSlotFillQuestion,	97✔
194
195	preciseSlotFillAnswer,	97✔
196	impreciseSlotFillAnswer	97✔
197	};

stanford-oval / genie-toolkit / 2344

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