1431

pending completion

Build # 1431

Build Type

Pull #375

travis-ci-com

Committed by

web-flow

Commit Message

Merge 2430b3c9f into b524ea64b

Pull Request Pull Request #375: Third PR of TypeScript conversion

Run Details

7244 of 15657 branches covered (46.27%)

Branch coverage included in aggregate %.

737 of 941 new or added lines in 51 files covered. (78.32%)

267 existing lines in 21 files now uncovered.

17327 of 30410 relevant lines covered (56.98%)

1490057.27 hits per line

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

93.1

/lib/languages/thingtalk/syntax.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 * as Tp from 'thingpedia';

import { Ast, SchemaRetriever, Grammar, NNSyntax } from 'thingtalk';
import GenieEntityRetriever from './entity-retriever';
import type { EntityMap } from '../../utils/entity-utils';

interface ParseOptions {
    thingpediaClient : Tp.BaseClient;
    schemaRetriever ?: SchemaRetriever;
}

export async function parse(code : string, options : ParseOptions) : Promise<Ast.Input> {
    const tpClient = options.thingpediaClient;
    if (!options.schemaRetriever)
        options.schemaRetriever = new SchemaRetriever(tpClient, null, true);

    assert(code);
    const state = await Grammar.parseAndTypecheck(code, options.schemaRetriever, false);
    return state;
}

export async function parsePrediction(code : string|string[], entities : EntityMap, options : ParseOptions) : Promise<Ast.Input|null> {
    const tpClient = options.thingpediaClient;
    if (!options.schemaRetriever)
        options.schemaRetriever = new SchemaRetriever(tpClient, null, true);

    const schemas = options.schemaRetriever;
    try {
        if (typeof code === 'string')
            code = code.split(' ');
        const state = NNSyntax.fromNN(code, entities).optimize();
        if (!state)
            return null;
        await state.typecheck(schemas, true);

        // convert the program to NN syntax once, which will force the program to be syntactically normalized
        // (and therefore rearrange slot-fill by name rather than Thingpedia order)
        NNSyntax.toNN(state, [], {}, { allocateEntities: true });
        return state;
    } catch(e) {
        return null;
    }
}

interface SerializeOptions {
    allocateEntities ?: boolean;
    typeAnnotations ?: boolean;
    locale ?: string;
    ignoreSentence ?: boolean;
}

export function serializeNormalized(program : Ast.Input, entities : EntityMap = {}, options : SerializeOptions = {}) : [string[], EntityMap] {
    options.allocateEntities = true;
    options.typeAnnotations = false;
    const code : string[] = NNSyntax.toNN(program, [], entities, options);
    return [code, entities];
}

export function serialize(ast : Ast.Input, sentence : string[], entities : EntityMap) : string[] {
    const clone = {};
    Object.assign(clone, entities);

    const sequence : string[] = NNSyntax.toNN(ast, sentence, clone);
    //ThingTalk.NNSyntax.fromNN(sequence, {});

    if (sequence.some((t) => t.endsWith(':undefined')))
        throw new TypeError(`Generated undefined type`);

    return sequence;
}

/**
 * Convert the prediction to a sequence of tokens to predict.
 *
 * This is same as {@link serialize} but we apply certain dialogue-specific heuristics.
 */
export function serializePrediction(prediction : Ast.Input,
                                    sentence : string[],
                                    entities : EntityMap,
                                    forTarget : 'user'|'agent',
                                    options : SerializeOptions) : string[] {
    if (forTarget === 'user') {
        const entityRetriever = new GenieEntityRetriever(sentence, entities, {
            locale: options.locale!,
            allowNonConsecutive: true,
            useHeuristics: true,
            alwaysAllowStrings: true,
            ignoreSentence: options.ignoreSentence || false,
        });
        return NNSyntax.toNN(prediction, sentence, entityRetriever, {
            typeAnnotations: false
        });
    } else {
        return NNSyntax.toNN(prediction, sentence, entities, {
            allocateEntities: true,
            typeAnnotations: false
        });
    }
}

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';	54✔
23	import * as Tp from 'thingpedia';
24
25	import { Ast, SchemaRetriever, Grammar, NNSyntax } from 'thingtalk';	54✔
26	import GenieEntityRetriever from './entity-retriever';	54✔
27	import type { EntityMap } from '../../utils/entity-utils';
28
29	interface ParseOptions {
30	thingpediaClient : Tp.BaseClient;
31	schemaRetriever ?: SchemaRetriever;
32	}
33
34	export async function parse(code : string, options : ParseOptions) : Promise<Ast.Input> {	54✔
35	const tpClient = options.thingpediaClient;	44,571✔
36	if (!options.schemaRetriever)	44,571✔
37	options.schemaRetriever = new SchemaRetriever(tpClient, null, true);	2✔
38
39	assert(code);	44,571✔
40	const state = await Grammar.parseAndTypecheck(code, options.schemaRetriever, false);	44,571✔
41	return state;	44,571✔
42	}
43
44	export async function parsePrediction(code : string\|string[], entities : EntityMap, options : ParseOptions) : Promise<Ast.Input\|null> {	54✔
45	const tpClient = options.thingpediaClient;	4✔
46	if (!options.schemaRetriever)	4✔
47	options.schemaRetriever = new SchemaRetriever(tpClient, null, true);	2✔
48
49	const schemas = options.schemaRetriever;	4✔
50	try {	4✔
51	if (typeof code === 'string')	4✔
52	code = code.split(' ');	2✔
53	const state = NNSyntax.fromNN(code, entities).optimize();	4✔
54	if (!state)	2!
NEW 55	return null;	×
56	await state.typecheck(schemas, true);	2✔
57
58	// convert the program to NN syntax once, which will force the program to be syntactically normalized
59	// (and therefore rearrange slot-fill by name rather than Thingpedia order)
60	NNSyntax.toNN(state, [], {}, { allocateEntities: true });	2✔
61	return state;	2✔
62	} catch(e) {
63	return null;	2✔
64	}
65	}
66
67	interface SerializeOptions {
68	allocateEntities ?: boolean;
69	typeAnnotations ?: boolean;
70	locale ?: string;
71	ignoreSentence ?: boolean;
72	}
73
74	export function serializeNormalized(program : Ast.Input, entities : EntityMap = {}, options : SerializeOptions = {}) : [string[], EntityMap] {	54✔
75	options.allocateEntities = true;	14,898✔
76	options.typeAnnotations = false;	14,898✔
77	const code : string[] = NNSyntax.toNN(program, [], entities, options);	14,898✔
78	return [code, entities];	14,898✔
79	}
80
81	export function serialize(ast : Ast.Input, sentence : string[], entities : EntityMap) : string[] {	54✔
82	const clone = {};	614,503✔
83	Object.assign(clone, entities);	614,503✔
84
85	const sequence : string[] = NNSyntax.toNN(ast, sentence, clone);	614,503✔
86	//ThingTalk.NNSyntax.fromNN(sequence, {});
87
88	if (sequence.some((t) => t.endsWith(':undefined')))	3,512,973!
89	throw new TypeError(`Generated undefined type`);	×
90
91	return sequence;	614,503✔
92	}
93
94	/**
95	* Convert the prediction to a sequence of tokens to predict.
96	*
97	* This is same as {@link serialize} but we apply certain dialogue-specific heuristics.
98	*/
99	export function serializePrediction(prediction : Ast.Input,	54✔
100	sentence : string[],
101	entities : EntityMap,
102	forTarget : 'user'\|'agent',
103	options : SerializeOptions) : string[] {
104	if (forTarget === 'user') {	22,226✔
105	const entityRetriever = new GenieEntityRetriever(sentence, entities, {	14,777✔
106	locale: options.locale!,
107	allowNonConsecutive: true,
108	useHeuristics: true,
109	alwaysAllowStrings: true,
110	ignoreSentence: options.ignoreSentence \|\| false,	29,554✔
111	});
112	return NNSyntax.toNN(prediction, sentence, entityRetriever, {	14,777✔
113	typeAnnotations: false
114	});
115	} else {
116	return NNSyntax.toNN(prediction, sentence, entities, {	7,449✔
117	allocateEntities: true,
118	typeAnnotations: false
119	});
120	}
121	}

stanford-oval / genie-toolkit / 1431

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