1625

pending completion

Build # 1625

Build Type

Pull #448

travis-ci-com

Committed by

web-flow

Commit Message

Merge d7fc334d8 into d418bae62

Pull Request Pull Request #448: Dialogue logging with test mode

Run Details

10754 of 23249 branches covered (46.26%)

Branch coverage included in aggregate %.

87 of 111 new or added lines in 4 files covered. (78.38%)

25 existing lines in 8 files now uncovered.

25259 of 43820 relevant lines covered (57.64%)

516003.69 hits per line

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

69.33

/lib/dialogue-agent/user-input.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 * as Tp from 'thingpedia';
import { Ast, Type, SchemaRetriever } from 'thingtalk';

import ValueCategory from './value-category';
import { EntityMap } from '../utils/entity-utils';
import * as ThingTalkUtils from '../utils/thingtalk';

export interface PlatformData {
    contacts ?: Array<{
        value : string;
        principal : string;
        display : string;
    }>;
}

export interface PreparsedCommand {
    code : string[];
    entities : EntityMap;
    slots ?: string[];
    slotTypes ?: Record<string, string>;
}

function parseSpecial(intent : Ast.SpecialControlIntent,
                      context : { command : string|null, platformData : PlatformData }) {
    switch (intent.type) {
    case 'yes':
        return new UserInput.Answer(new Ast.Value.Boolean(true), context.command, context.platformData);
    case 'no':
        return new UserInput.Answer(new Ast.Value.Boolean(false), context.command, context.platformData);
    default:
        return new UserInput.UICommand(intent.type, context.platformData);
    }
}

/**
 * Base class for the interpretation of the input from the user, which could be
 * a UI action (a button) or a natural language command.
 */
class UserInput {
    utterance : string|null;
    platformData : PlatformData;

    constructor(utterance : string|null, platformData : PlatformData) {
        this.utterance = utterance;
        this.platformData = platformData;
    }

    static fromThingTalk(thingtalk : Ast.Input,
                         context : { command : string|null, platformData : PlatformData }) : UserInput {
        if (thingtalk instanceof Ast.ControlCommand) {
            if (thingtalk.intent instanceof Ast.SpecialControlIntent)
                return parseSpecial(thingtalk.intent, context);
            else if (thingtalk.intent instanceof Ast.AnswerControlIntent)
                return new UserInput.Answer(thingtalk.intent.value, context.command, context.platformData);
            else if (thingtalk.intent instanceof Ast.ChoiceControlIntent)
                return new UserInput.MultipleChoiceAnswer(thingtalk.intent.value, context.command, context.platformData);
            else
                throw new TypeError(`Unrecognized bookkeeping intent`);
        } else if (thingtalk instanceof Ast.Program) {
            return new UserInput.Program(thingtalk, context.command, context.platformData);
        } else if (thingtalk instanceof Ast.DialogueState) {
            return new UserInput.DialogueState(thingtalk, context.command, context.platformData);
        } else {
            throw new TypeError(`Unrecognized ThingTalk command: ${thingtalk.prettyprint()}`);
        }
    }

    static async parse(json : { program : string }|PreparsedCommand,
                       thingpediaClient : Tp.BaseClient,
                       schemaRetriever : SchemaRetriever,
                       context : { command : string|null, platformData : PlatformData }) : Promise<UserInput> {
        if ('program' in json) {
            return UserInput.fromThingTalk(await ThingTalkUtils.parse(json.program, {
                thingpediaClient,
                schemaRetriever,
                loadMetadata: true
            }), context);
        }

        const { code, entities } = json;
        for (const name in entities) {
            if (name.startsWith('SLOT_')) {
                const slotname = json.slots![parseInt(name.substring('SLOT_'.length))];
                const slotType = Type.fromString(json.slotTypes![slotname]);
                const value = Ast.Value.fromJSON(slotType, entities[name]);
                entities[name] = value;
            }
        }

        const thingtalk = await ThingTalkUtils.parsePrediction(code, entities, {
            thingpediaClient,
            schemaRetriever,
            loadMetadata: true
        }, true);
        return UserInput.fromThingTalk(thingtalk, context);
    }
}

namespace UserInput {
    /**
     * A natural language command that was parsed correctly but is not supported in
     * Thingpedia (it uses Thingpedia classes that are not available).
     */
    export class Unsupported extends UserInput {}

    /**
     * A natural language command that failed to parse entirely.
     */
    export class Failed extends UserInput {}

    /**
     * A special command that bypasses the neural network, or a button on the UI.
     */
    export class UICommand extends UserInput {
        constructor(public type : string,
                    platformData : PlatformData) {
            super(null, platformData);
        }
    }

    /**
     * A multiple choice answer. This can be generated by the UI button,
     * or by the parser in multiple choice mode. It is only used to disambiguate
     * entities and device names
     */
    export class MultipleChoiceAnswer extends UserInput {
        category : ValueCategory.MultipleChoice = ValueCategory.MultipleChoice;

        constructor(public value : number,
                    utterance : string|null,
                    platformData : PlatformData) {
            super(utterance, platformData);
        }
    }

    /**
     * A single, naked ThingTalk value. This can be generated by the UI pickers
     * (file pickers, location pickers, contact pickers, etc.), in certain uses
     * of the exact matcher, and when the agent is in raw mode.
     */
    export class Answer extends UserInput {
        category : ValueCategory;

        constructor(public value : Ast.Value,
                    utterance : string|null,
                    platformData : PlatformData) {
            super(utterance, platformData);
            this.category = ValueCategory.fromValue(value);
        }
    }

    /**
     * A single ThingTalk program. This can come from a single-command neural network,
     * or from the user typing "\t".
     */
    export class Program extends UserInput {
        constructor(public program : Ast.Program,
                    utterance : string|null,
                    platformData : PlatformData) {
            super(utterance, platformData);
        }
    }

    /**
     * A prediction ThingTalk dialogue state (policy, dialogue act, statements), which
     * is generated by the neural network after parsing the user's input.
     */
    export class DialogueState extends UserInput {
        constructor(public prediction : Ast.DialogueState,
                    utterance : string|null,
                    platformData : PlatformData) {
            super(utterance, platformData);
        }
    }
}

export default UserInput;

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	import * as Tp from 'thingpedia';
22	import { Ast, Type, SchemaRetriever } from 'thingtalk';	61✔
23
24	import ValueCategory from './value-category';	61✔
25	import { EntityMap } from '../utils/entity-utils';
26	import * as ThingTalkUtils from '../utils/thingtalk';	61✔
27
28	export interface PlatformData {
29	contacts ?: Array<{
30	value : string;
31	principal : string;
32	display : string;
33	}>;
34	}
35
36	export interface PreparsedCommand {
37	code : string[];
38	entities : EntityMap;
39	slots ?: string[];
40	slotTypes ?: Record<string, string>;
41	}
42
43	function parseSpecial(intent : Ast.SpecialControlIntent,
44	context : { command : string\|null, platformData : PlatformData }) {
45	switch (intent.type) {	52✔
46	case 'yes':	52✔
47	return new UserInput.Answer(new Ast.Value.Boolean(true), context.command, context.platformData);	3✔
48	case 'no':
49	return new UserInput.Answer(new Ast.Value.Boolean(false), context.command, context.platformData);	3✔
50	default:
51	return new UserInput.UICommand(intent.type, context.platformData);	46✔
52	}
53	}
54
55	/**
56	* Base class for the interpretation of the input from the user, which could be
57	* a UI action (a button) or a natural language command.
58	*/
59	class UserInput {
60	utterance : string\|null;
61	platformData : PlatformData;
62
63	constructor(utterance : string\|null, platformData : PlatformData) {
64	this.utterance = utterance;	114✔
65	this.platformData = platformData;	114✔
66	}
67
68	static fromThingTalk(thingtalk : Ast.Input,
69	context : { command : string\|null, platformData : PlatformData }) : UserInput {
70	if (thingtalk instanceof Ast.ControlCommand) {	112✔
71	if (thingtalk.intent instanceof Ast.SpecialControlIntent)	53✔
72	return parseSpecial(thingtalk.intent, context);	52✔
73	else if (thingtalk.intent instanceof Ast.AnswerControlIntent)	1!
74	return new UserInput.Answer(thingtalk.intent.value, context.command, context.platformData);	1✔
75	else if (thingtalk.intent instanceof Ast.ChoiceControlIntent)	×
NEW 76	return new UserInput.MultipleChoiceAnswer(thingtalk.intent.value, context.command, context.platformData);	×
77	else
78	throw new TypeError(`Unrecognized bookkeeping intent`);	×
79	} else if (thingtalk instanceof Ast.Program) {	59!
NEW 80	return new UserInput.Program(thingtalk, context.command, context.platformData);	×
81	} else if (thingtalk instanceof Ast.DialogueState) {	59!
82	return new UserInput.DialogueState(thingtalk, context.command, context.platformData);	59✔
83	} else {
84	throw new TypeError(`Unrecognized ThingTalk command: ${thingtalk.prettyprint()}`);	×
85	}
86	}
87
88	static async parse(json : { program : string }\|PreparsedCommand,
89	thingpediaClient : Tp.BaseClient,
90	schemaRetriever : SchemaRetriever,
91	context : { command : string\|null, platformData : PlatformData }) : Promise<UserInput> {
92	if ('program' in json) {	112✔
93	return UserInput.fromThingTalk(await ThingTalkUtils.parse(json.program, {	61✔
94	thingpediaClient,
95	schemaRetriever,
96	loadMetadata: true
97	}), context);
98	}
99
100	const { code, entities } = json;	51✔
101	for (const name in entities) {	51✔
102	if (name.startsWith('SLOT_')) {	×
103	const slotname = json.slots![parseInt(name.substring('SLOT_'.length))];	×
104	const slotType = Type.fromString(json.slotTypes![slotname]);	×
105	const value = Ast.Value.fromJSON(slotType, entities[name]);	×
106	entities[name] = value;	×
107	}
108	}
109
110	const thingtalk = await ThingTalkUtils.parsePrediction(code, entities, {	51✔
111	thingpediaClient,
112	schemaRetriever,
113	loadMetadata: true
114	}, true);
115	return UserInput.fromThingTalk(thingtalk, context);	51✔
116	}
117	}
118
119	namespace UserInput {	61!
120	/**
121	* A natural language command that was parsed correctly but is not supported in
122	* Thingpedia (it uses Thingpedia classes that are not available).
123	*/
124	export class Unsupported extends UserInput {}	61✔
125
126	/**
127	* A natural language command that failed to parse entirely.
128	*/
129	export class Failed extends UserInput {}	61✔
130
131	/**
132	* A special command that bypasses the neural network, or a button on the UI.
133	*/
134	export class UICommand extends UserInput {	61✔
135	constructor(public type : string,	46✔
136	platformData : PlatformData) {
137	super(null, platformData);	46✔
138	}
139	}
140
141	/**
142	* A multiple choice answer. This can be generated by the UI button,
143	* or by the parser in multiple choice mode. It is only used to disambiguate
144	* entities and device names
145	*/
146	export class MultipleChoiceAnswer extends UserInput {	61✔
147	category : ValueCategory.MultipleChoice = ValueCategory.MultipleChoice;	×
148
149	constructor(public value : number,	×
150	utterance : string\|null,
151	platformData : PlatformData) {
NEW 152	super(utterance, platformData);	×
153	}
154	}
155
156	/**
157	* A single, naked ThingTalk value. This can be generated by the UI pickers
158	* (file pickers, location pickers, contact pickers, etc.), in certain uses
159	* of the exact matcher, and when the agent is in raw mode.
160	*/
161	export class Answer extends UserInput {	61✔
162	category : ValueCategory;
163
164	constructor(public value : Ast.Value,	8✔
165	utterance : string\|null,
166	platformData : PlatformData) {
167	super(utterance, platformData);	8✔
168	this.category = ValueCategory.fromValue(value);	8✔
169	}
170	}
171
172	/**
173	* A single ThingTalk program. This can come from a single-command neural network,
174	* or from the user typing "\t".
175	*/
176	export class Program extends UserInput {	61✔
177	constructor(public program : Ast.Program,	×
178	utterance : string\|null,
179	platformData : PlatformData) {
NEW 180	super(utterance, platformData);	×
181	}
182	}
183
184	/**
185	* A prediction ThingTalk dialogue state (policy, dialogue act, statements), which
186	* is generated by the neural network after parsing the user's input.
187	*/
188	export class DialogueState extends UserInput {	61✔
189	constructor(public prediction : Ast.DialogueState,	59✔
190	utterance : string\|null,
191	platformData : PlatformData) {
192	super(utterance, platformData);	59✔
193	}
194	}
195	}
196
197	export default UserInput;	61✔

stanford-oval / genie-toolkit / 1625

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