1699

pending completion

Build # 1699

Build Type

Pull #491

travis-ci-com

Committed by

web-flow

Commit Message

Merge fa041bfeb into 8b3d18863

Pull Request Pull Request #491: Assorted bug fixes

Run Details

10880 of 23312 branches covered (46.67%)

Branch coverage included in aggregate %.

14 of 29 new or added lines in 6 files covered. (48.28%)

22 existing lines in 7 files now uncovered.

25432 of 43951 relevant lines covered (57.86%)

545379.77 hits per line

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

90.07

/languages/thingtalk/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, } 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!);
        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 preciseSlotFillAnswer(ctx : ContextInfo, answer : Ast.Invocation) {
    const questions = ctx.state.dialogueActParam;
    assert(questions);
    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 = ctx.next.clone();
    clone.confirm = 'accepted';
    clone.results = null;
    const newInvocation = C.getInvocation(clone);
    // 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;
    assert(Array.isArray(questions));
    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 (!ptype.equals(answer.getType()))
            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 = ctx.next.clone();
    clone.confirm = 'accepted';
    clone.results = null;
    const newAction = C.getInvocation(clone);
    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';	2✔
23
24	import { Ast, } from 'thingtalk';	2✔
25
26	import * as C from '../ast_manip';	2✔
27
28	import {	2✔
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!);	5,195✔
40	assert(action instanceof Ast.Invocation);	5,195✔
41	for (const q of questions) {	5,195✔
42	if (!C.isSameFunction(q.schema, action.schema!))	5,408✔
43	return false;	4,581✔
44	if (q.name === ctx.nextInfo!.chainParameter)	827✔
45	return false;	8✔
46	const arg = action.schema!.getArgument(q.name);	819✔
47	if (!arg \|\| !arg.is_input)	819!
48	return false;	×
49	for (const in_param of action.in_params) {	819✔
50	if (in_param.name === q.name && !in_param.value.isUndefined)	1,787✔
51	return false;	273✔
52	}
53	}
54	return true;	333✔
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;	197✔
62	if (!type.isString)	197✔
63	return false;	139✔
64
65	// if the developer specified what to do for the argument, it is authoritative
66	const annotation = arg.getAnnotation<boolean>('raw_mode');	58✔
67	if (annotation !== undefined)	58!
68	return annotation;	×
69
70	// use raw mode for free-form text parameters
71	const stringvalues = arg.getAnnotation<string>('string_values');	58✔
72	if (!stringvalues)	58!
73	return false;	×
74	return ['tt:short_free_text', 'tt:long_free_text'].includes(stringvalues);	58✔
75	}
76
77
78	function makeSlotFillQuestion(ctx : ContextInfo, questions : C.ParamSlot[]) {
79	if (!isGoodSlotFillQuestion(ctx, questions))	5,195✔
80	return null;	4,862✔
81
82	assert(questions.length > 0);	333✔
83	if (questions.length === 1) {	333✔
84	const action = C.getInvocation(ctx.next!);	197✔
85	const arg = action.schema!.getArgument(questions[0].name)!;	197✔
86	const type = arg.type;	197✔
87
88	const raw = useRawModeForSlotFill(arg);	197✔
89	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_slot_fill', questions.map((q) => q.name)), null, type, { raw });	197✔
90	}
91	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_slot_fill', questions.map((q) => q.name)));	272✔
92	}
93
94	/**
95	* Check if the action has parameters for the `questions`
96	*/
97	function isSlotFillAnswerValidForQuestion(action : Ast.Invocation, questions : string[]) {
98	assert(Array.isArray(questions));	1,086✔
99	assert(action instanceof Ast.Invocation);	1,086✔
100	return questions.every((question) => {	1,086✔
101	for (const in_param of action.in_params) {	1,200✔
102	if (in_param.name === question)	1,812✔
103	return !in_param.value.isUndefined;	1,069✔
104	}
105	return false;	131✔
106	});
107	}
108
109	function preciseSlotFillAnswer(ctx : ContextInfo, answer : Ast.Invocation) {
110	const questions = ctx.state.dialogueActParam;	1,086✔
111	assert(questions);	1,086✔
112	if (!isSlotFillAnswerValidForQuestion(answer, questions))	1,086✔
113	return null;	324✔
114	if (!C.isSameFunction(answer.schema!, ctx.nextFunction!))	762!
115	return null;	×
116	assert(answer instanceof Ast.Invocation);	762✔
117	assert(ctx.next && ctx.nextInfo);	762✔
118
119	// check that we don't fill the chain parameter through this path:
120	// the chain parameter can only be filled if the agent shows the results
121	for (const in_param of answer.in_params) {	762✔
122	if (in_param.name === ctx.nextInfo.chainParameter &&	1,177!
123	!ctx.nextInfo.chainParameterFilled)
124	return null;	×
125	}
126
127	const clone = ctx.next.clone();	762✔
128	clone.confirm = 'accepted';	762✔
129	clone.results = null;	762✔
130	const newInvocation = C.getInvocation(clone);	762✔
131	// modify in place
132	mergeParameters(newInvocation, answer);	762✔
133
134	return addNewItem(ctx, 'execute', null, 'accepted', clone);	762✔
135	}
136
137	function impreciseSlotFillAnswer(ctx : ContextInfo, answer : Ast.Value\|C.InputParamSlot) {
138	const questions = ctx.state.dialogueActParam;	62,680✔
139	assert(Array.isArray(questions));	62,680✔
140	if (questions.length !== 1)	62,680✔
141	return null;	14,207✔
142
143	let ipslot : C.InputParamSlot;
144	if (answer instanceof Ast.Value) {	48,473✔
145	assert(questions.length === 1);	33,338✔
146
147	const ptype = ctx.nextFunction!.getArgType(questions[0])!;	33,338✔
148	if (!ptype.equals(answer.getType()))	33,338✔
149	return null;	33,200✔
150	ipslot = {	138✔
151	schema: ctx.nextFunction!,
152	ptype: ptype,
153	ast: new Ast.InputParam(null, questions[0], answer)
154	};
155	} else {
156	ipslot = answer;	15,135✔
157	if (!questions.some((q) => q === ipslot.ast.name))	15,135✔
158	return null;	14,902✔
159	if (!C.isSameFunction(answer.schema, ctx.nextFunction!))	233!
UNCOV 160	return null;	×
161	}
162
163	assert(ctx.next && ctx.nextInfo);	371✔
164	if (ipslot.ast.name === ctx.nextInfo.chainParameter)	371!
165	return null;	×
166
167	const clone = ctx.next.clone();	371✔
168	clone.confirm = 'accepted';	371✔
169	clone.results = null;	371✔
170	const newAction = C.getInvocation(clone);	371✔
171	if (!C.checkInvocationInputParam(ctx.loader, newAction, ipslot))	371✔
172	return null;	1✔
173
174	// modify in place
175	setOrAddInvocationParam(newAction, ipslot.ast.name, ipslot.ast.value);	370✔
176	return addNewItem(ctx, 'execute', null, 'accepted', clone);	370✔
177	}
178
179	export {
180	makeSlotFillQuestion,	2✔
181
182	preciseSlotFillAnswer,	2✔
183	impreciseSlotFillAnswer	2✔
184	};

stanford-oval / genie-toolkit / 1699

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