1020

pending completion

Build # 1020

Build Type

Pull #214

travis-ci-com

Committed by

web-flow

Commit Message

Merge 181524e5f into 26b8cb60e

Pull Request Pull Request #214: Auto annotate multiwoz

Run Details

5232 of 12213 branches covered (42.84%)

Branch coverage included in aggregate %.

2 of 14 new or added lines in 2 files covered. (14.29%)

2403 existing lines in 57 files now uncovered.

12888 of 23722 relevant lines covered (54.33%)

2266975.62 hits per line

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

3.13

/tool/autoqa/lib/canonical-generator.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: Silei Xu <silei@cs.stanford.edu>
"use strict";
const fs = require('fs');
const util = require('util');
const path = require('path');
const stemmer = require('stemmer');
const Inflectors = require('en-inflectors').Inflectors;
const child_process = require('child_process');

const utils = require('../../../lib/utils/misc-utils');
const { makeLookupKeys } = require('../../../lib/dataset-tools/mturk/sample-utils');
const EnglishLanguagePack = require('../../../lib/i18n/american-english');
const { clean } = require('../../../lib/utils/misc-utils');

const CanonicalExtractor = require('./canonical-extractor');
const genBaseCanonical = require('./base-canonical-generator');

// extract entity type from type
function typeToEntityType(type) {
    if (type.isArray)
        return typeToEntityType(type.elem);
    else if (type.isEntity)
        return type.type;
    else
        return null;
}

class AutoCanonicalGenerator {
    constructor(classDef, constants, functions, parameterDatasets, options) {
        this.class = classDef;
        this.constants = constants;
        this.functions = functions ? functions : Object.keys(classDef.queries).concat(Object.keys(classDef.actions));

        this.algorithm = options.algorithm ? options.algorithm.split(',') : [];
        this.pruning = options.pruning;
        this.mask = options.mask;
        this.is_paraphraser = options.is_paraphraser;
        this.model = options.model;
        this.gpt2_ordering = options.gpt2_ordering;
        this.paraphraser_model = options.paraphraser_model;

        this.parameterDatasets = parameterDatasets;
        this.parameterDatasetPaths = {};

        this.options = options;

        if (options.dataset !== 'custom' && fs.existsSync(`../${options.dataset}/manual-annotations`)) {
            this.manualAnnotations = require(`../${options.dataset}/manual-annotations`);
            this.annotatedProperties = Object.keys(this.manualAnnotations.MANUAL_PROPERTY_CANONICAL_OVERRIDE);
        } else {
            this.annotatedProperties = [];
        }
        this._langPack = new EnglishLanguagePack();
    }

    async generate() {
        await this._loadParameterDatasetPaths();
        const functions = {};
        for (let fname of this.functions) {
            let func = this.class.queries[fname] || this.class.actions[fname];
            functions[fname] = {
                type: this.class.queries[fname] ? 'query' : 'action',
                canonical: func.canonical || clean(fname),
                args: {}
            };
            if (Array.isArray(functions[fname].canonical))
                functions[fname].canonical = functions[fname].canonical[0];

            let typeCounts = this._getArgTypeCount(func);
            for (let arg of func.iterateArguments()) {
                const argobj = {};

                if (this.annotatedProperties.includes(arg.name) || arg.name === 'id')
                    continue;

                // TODO: bert on counted object only for these args
                if (arg.metadata.counted_object)
                    continue;

                if (arg.name.includes('.') && this.annotatedProperties.includes(arg.name.slice(arg.name.indexOf('.') + 1)))
                    continue;

                // some args don't have canonical: e.g., id, name
                if (!arg.metadata.canonical)
                    continue;

                // get the paths to the data
                let datasetTypeAndPath = this._getDatasetPath(fname, arg);
                if (datasetTypeAndPath) {
                    let [datasetType, datasetPath] = datasetTypeAndPath;
                    datasetPath = path.dirname(this.parameterDatasets) + '/' + datasetPath;
                    if (datasetPath && fs.existsSync(datasetPath))
                        argobj['path'] = [datasetType, datasetPath];
                }

                let canonical = arg.metadata.canonical;
                if (this.options.remove_existing_canonicals) {
                    canonical = {};
                    genBaseCanonical(canonical, arg.name, arg.type);
                } else {
                    if (typeof canonical === 'string')
                        canonical = { base: [canonical] };
                    else if (Array.isArray(canonical))
                        canonical = { base: canonical };
                }
                arg.metadata.canonical = canonical;
                for (let type in canonical) {
                    if (!Array.isArray(canonical[type]))
                        canonical[type] = [canonical[type]];
                }

                // remove function name in arg name, normally it's repetitive
                for (let type in canonical) {
                    canonical[type] = canonical[type].map((c) => {
                        if (c.startsWith(fname.toLowerCase() + ' '))
                            return c.slice(fname.toLowerCase().length + 1);
                        return c;
                    });
                }

                // copy base canonical if property canonical is missing
                if (canonical.base && !canonical.property)
                    canonical.property = [...canonical.base];

                let typestr = typeToEntityType(func.getArgType(arg.name));

                if (typestr && typeCounts[typestr] === 1) {
                    // if an entity is unique, allow dropping the property name entirely
                    if (!this.functions.includes(typestr.substring(typestr.indexOf(':') + 1)))
                        canonical.property.push('#');

                    // if it's the only people entity, adding adjective form
                    // E.g., author for review - bob's review
                    //       byArtist for MusicRecording - bob's song
                    if (typestr.endsWith(':Person'))
                        canonical.adjective = ["# 's", '#'];
                }

                // if property is missing, try to use entity type info
                if (!('property' in canonical)) {
                    // only apply this if there is only one property uses this entity type
                    if (typestr && typeCounts[typestr] === 1) {
                        let base = utils.clean(typestr.substring(typestr.indexOf(':') + 1));
                        canonical['property'] = [base];
                        canonical['base'] = [base];
                    }
                }
                argobj['canonicals'] = canonical;

                const samples = this._retrieveSamples(fname, arg);
                if (samples)
                    argobj['values'] = samples;

                functions[fname]['args'][arg.name] = argobj;
            }
        }

        if (this.algorithm.length > 0) {
            const args = [path.resolve(path.dirname(module.filename), './bert-canonical-annotator.py'), 'all'];
            if (this.is_paraphraser)
                args.push('--is-paraphraser');
            if (this.gpt2_ordering)
                args.push('--gpt2-ordering');
            if (this.pruning) {
                args.push('--pruning-threshold');
                args.push(this.pruning);
            }
            args.push('--model-name-or-path');
            args.push(this.model);
            args.push(this.mask ? '--mask' : '--no-mask');

            // call bert to generate candidates
            const child = child_process.spawn(`python3`, args, {stdio: ['pipe', 'pipe', 'inherit']});

            const output = util.promisify(fs.writeFile);
            if (this.options.debug)
                await output(`./bert-canonical-annotator-in.json`, JSON.stringify(functions, null, 2));

            const stdout = await new Promise((resolve, reject) => {
                child.stdin.write(JSON.stringify(functions));
                child.stdin.end();
                child.on('error', reject);
                child.stdout.on('error', reject);
                child.stdout.setEncoding('utf8');
                let buffer = '';
                child.stdout.on('data', (data) => {
                    buffer += data;
                });
                child.stdout.on('end', () => resolve(buffer));
            });

            if (this.options.debug) {
                try {
                    await output(`./bert-canonical-annotator-out.json`, JSON.stringify(JSON.parse(stdout), null, 2));
                } catch (e) {
                     await output(`./bert-canonical-annotator-out.json`, stdout);
                }
            }

            const {synonyms, adjectives } = JSON.parse(stdout);
            if (this.algorithm.includes('bert') || this.algorithm.includes('adj'))
                this._updateCanonicals(synonyms, adjectives);
            if (this.algorithm.includes('bart')) {
                const extractor = new CanonicalExtractor(this.class, this.functions, this.paraphraser_model, this.options);
                await extractor.run(synonyms, functions);
            }
        }

        return this.class;
    }

    _getArgTypeCount(schema) {
        const count = {};
        for (let arg of schema.iterateArguments()) {
            let typestr = typeToEntityType(schema.getArgType(arg.name));
            if (!typestr)
                continue;
            count[typestr] = (count[typestr] || 0) + 1;
        }
        return count;
    }

    async _loadParameterDatasetPaths() {
        const rows = (await (util.promisify(fs.readFile))(this.parameterDatasets, { encoding: 'utf8' })).split('\n');
        for (let row of rows) {
            let [type, /*locale*/, key, path] = row.split('\t');
            this.parameterDatasetPaths[key] = [type, path];
        }
    }

    _getDatasetPath(qname, arg) {
        const keys = [];
        const stringValueAnnotation = arg.getImplementationAnnotation('string_values');
        if (stringValueAnnotation)
            keys.push(stringValueAnnotation);
        keys.push(`${this.class.kind}:${qname}_${arg.name}`);
        const elementType = arg.type.isArray ? arg.type.elem : arg.type;
        if (!elementType.isCompound)
            keys.push(elementType.isEntity ? elementType.type : elementType);

        for (let key of keys) {
            if (this.parameterDatasetPaths[key])
                return this.parameterDatasetPaths[key];
        }
        return null;
    }

    _updateCanonicals(candidates, adjectives) {
        for (let fname of this.functions) {
            let func = this.class.queries[fname] || this.class.actions[fname];
            for (let arg in candidates[fname]) {
                if (arg === 'id')
                    continue;
                let canonicals = func.getArgument(arg).metadata.canonical;
                if (!canonicals)
                    throw new Error(`Missing canonical form for ${arg} in @${func.class.name}.${func.name}`);
                if (typeof canonicals === 'string')
                    canonicals = { base: [canonicals] };
                else if (Array.isArray(canonicals))
                    canonicals = { base: canonicals };

                if (this.algorithm.includes('adj') && adjectives.includes(`${fname}.${arg}`))
                    canonicals['adjective'] = ['#'];

                if (this.algorithm.includes('bert')) {
                    for (let type in candidates[fname][arg]) {
                        for (let candidate in candidates[fname][arg][type]) {
                            if (this._hasConflict(fname, arg, type, candidate))
                                continue;
                            if (type === 'reverse_verb' && !this._isVerb(candidate))
                                continue;
                            if (!canonicals[type].includes(candidate))
                                canonicals[type].push(candidate);
                        }
                    }

                    if (canonicals.reverse_verb && canonicals.reverse_verb.length === 1) {
                        // FIXME: a hack, when there is only one candidate for reverse verb, it means the inflector noun
                        //  to verb doesn't work, add the following heuristics
                        const base = (new Inflectors(canonicals.base[0])).toSingular();
                        if (base.endsWith('or') || base.endsWith('er'))
                            canonicals.reverse_verb.push(base.slice(0, -2) + 'ed');
                        canonicals.reverse_verb.push(base);
                    }
                }
            }
        }
    }

    _isVerb(candidate) {
        if (candidate === 'is' || candidate === 'are')
            return false;

        return ['VBP', 'VBZ', 'VBD'].includes(this._langPack.posTag([candidate])[0]);
    }

    _hasConflict(fname, currentArg, currentPos, currentCanonical) {
        const func = this.class.queries[fname] || this.class.actions[fname];
        currentArg = func.getArgument(currentArg);
        const currentStringset = currentArg.getImplementationAnnotation('string_values');
        for (let arg of func.iterateArguments()) {
            if (arg.name === currentArg.name)
                continue;

            // for non base, we only check conflict between arguments of the same type, or same string set
            if (currentPos !== 'base') {
                if (currentStringset) {
                    let stringset = arg.getImplementationAnnotation('string_values');
                    if (stringset && stringset !== currentStringset)
                        continue;
                }
                let currentType = currentArg.type.isArray ? currentArg.type.elem : currentArg.type;
                let type = arg.type.isArray ? arg.type.elem : arg.type;
                if (!currentType.equals(type))
                    continue;
            }

            const canonicals = arg.metadata.canonical;

            for (let pos in canonicals) {
                // if current pos is base, only check base
                if (currentPos === 'base' && pos !== 'base')
                    continue;
                // if current pos is not base, only check non-base
                if (currentPos !== 'base' && pos === 'base')
                    continue;
                let conflictFound = false;
                let todelete = [];
                for (let i = 0; i < canonicals[pos].length; i++) {
                    let canonical = canonicals[pos][i];
                    if (stemmer(canonical) === stemmer(currentCanonical)) {
                        // conflict with the base canonical phrase of another parameter, return true directly
                        if (i === 0)
                            return true;
                        // conflict with generate canonicals of another parameter, remove conflicts, then return true
                        conflictFound = true;
                        todelete.push(canonical);
                    }
                }
                if (conflictFound) {
                    for (let canonical of todelete) {
                        let index = canonicals[pos].indexOf(canonical);
                        canonicals[pos].splice(index, 1);
                    }
                    return true;
                }
            }
        }

        //TODO: also consider conflicts between candidates

        return false;
    }

    _retrieveSamples(qname, arg) {
        //TODO: also use enum canonicals?
        if (arg.type.isEnum)
            return arg.type.entries.slice(0, 10).map(clean);

        const keys = makeLookupKeys('@' + this.class.kind + '.' + qname, arg.name, arg.type);
        let samples;
        for (let key of keys) {
            if (this.constants[key]) {
                samples = this.constants[key];
                break;
            }
        }
        if (samples) {
            samples = samples.map((v) => {
                if (arg.type.isString || (arg.type.isArray && arg.type.elem.isString))
                    return v.value;
                return v.display;
            });
        }
        return samples;
    }
}

module.exports = AutoCanonicalGenerator;

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: Silei Xu <silei@cs.stanford.edu>
20	"use strict";
21	const fs = require('fs');	26✔
22	const util = require('util');	26✔
23	const path = require('path');	26✔
24	const stemmer = require('stemmer');	26✔
25	const Inflectors = require('en-inflectors').Inflectors;	26✔
26	const child_process = require('child_process');	26✔
27
28	const utils = require('../../../lib/utils/misc-utils');	26✔
29	const { makeLookupKeys } = require('../../../lib/dataset-tools/mturk/sample-utils');	26✔
30	const EnglishLanguagePack = require('../../../lib/i18n/american-english');	26✔
31	const { clean } = require('../../../lib/utils/misc-utils');	26✔
32
33	const CanonicalExtractor = require('./canonical-extractor');	26✔
34	const genBaseCanonical = require('./base-canonical-generator');	26✔
35
36	// extract entity type from type
37	function typeToEntityType(type) {
UNCOV 38	if (type.isArray)	×
UNCOV 39	return typeToEntityType(type.elem);	×
UNCOV 40	else if (type.isEntity)	×
UNCOV 41	return type.type;	×
42	else
UNCOV 43	return null;	×
44	}
45
46	class AutoCanonicalGenerator {
47	constructor(classDef, constants, functions, parameterDatasets, options) {
UNCOV 48	this.class = classDef;	×
UNCOV 49	this.constants = constants;	×
UNCOV 50	this.functions = functions ? functions : Object.keys(classDef.queries).concat(Object.keys(classDef.actions));	×
51
UNCOV 52	this.algorithm = options.algorithm ? options.algorithm.split(',') : [];	×
UNCOV 53	this.pruning = options.pruning;	×
UNCOV 54	this.mask = options.mask;	×
UNCOV 55	this.is_paraphraser = options.is_paraphraser;	×
UNCOV 56	this.model = options.model;	×
UNCOV 57	this.gpt2_ordering = options.gpt2_ordering;	×
UNCOV 58	this.paraphraser_model = options.paraphraser_model;	×
59
UNCOV 60	this.parameterDatasets = parameterDatasets;	×
UNCOV 61	this.parameterDatasetPaths = {};	×
62
UNCOV 63	this.options = options;	×
64
UNCOV 65	if (options.dataset !== 'custom' && fs.existsSync(`../${options.dataset}/manual-annotations`)) {	×
66	this.manualAnnotations = require(`../${options.dataset}/manual-annotations`);	×
67	this.annotatedProperties = Object.keys(this.manualAnnotations.MANUAL_PROPERTY_CANONICAL_OVERRIDE);	×
68	} else {
UNCOV 69	this.annotatedProperties = [];	×
70	}
UNCOV 71	this._langPack = new EnglishLanguagePack();	×
72	}
73
74	async generate() {
UNCOV 75	await this._loadParameterDatasetPaths();	×
UNCOV 76	const functions = {};	×
UNCOV 77	for (let fname of this.functions) {	×
UNCOV 78	let func = this.class.queries[fname] \|\| this.class.actions[fname];	×
UNCOV 79	functions[fname] = {	×
80	type: this.class.queries[fname] ? 'query' : 'action',	×
81	canonical: func.canonical \|\| clean(fname),	×
82	args: {}
83	};
UNCOV 84	if (Array.isArray(functions[fname].canonical))	×
UNCOV 85	functions[fname].canonical = functions[fname].canonical[0];	×
86
UNCOV 87	let typeCounts = this._getArgTypeCount(func);	×
UNCOV 88	for (let arg of func.iterateArguments()) {	×
NEW 89	const argobj = {};	×
90
UNCOV 91	if (this.annotatedProperties.includes(arg.name) \|\| arg.name === 'id')	×
UNCOV 92	continue;	×
93
94	// TODO: bert on counted object only for these args
UNCOV 95	if (arg.metadata.counted_object)	×
UNCOV 96	continue;	×
97
UNCOV 98	if (arg.name.includes('.') && this.annotatedProperties.includes(arg.name.slice(arg.name.indexOf('.') + 1)))	×
99	continue;	×
100
101	// some args don't have canonical: e.g., id, name
UNCOV 102	if (!arg.metadata.canonical)	×
103	continue;	×
104
105	// get the paths to the data
NEW 106	let datasetTypeAndPath = this._getDatasetPath(fname, arg);	×
NEW 107	if (datasetTypeAndPath) {	×
NEW 108	let [datasetType, datasetPath] = datasetTypeAndPath;	×
NEW 109	datasetPath = path.dirname(this.parameterDatasets) + '/' + datasetPath;	×
NEW 110	if (datasetPath && fs.existsSync(datasetPath))	×
NEW 111	argobj['path'] = [datasetType, datasetPath];	×
112	}
113
UNCOV 114	let canonical = arg.metadata.canonical;	×
UNCOV 115	if (this.options.remove_existing_canonicals) {	×
116	canonical = {};	×
117	genBaseCanonical(canonical, arg.name, arg.type);	×
118	} else {
UNCOV 119	if (typeof canonical === 'string')	×
120	canonical = { base: [canonical] };	×
UNCOV 121	else if (Array.isArray(canonical))	×
122	canonical = { base: canonical };	×
123	}
UNCOV 124	arg.metadata.canonical = canonical;	×
UNCOV 125	for (let type in canonical) {	×
UNCOV 126	if (!Array.isArray(canonical[type]))	×
UNCOV 127	canonical[type] = [canonical[type]];	×
128	}
129
130	// remove function name in arg name, normally it's repetitive
UNCOV 131	for (let type in canonical) {	×
UNCOV 132	canonical[type] = canonical[type].map((c) => {	×
UNCOV 133	if (c.startsWith(fname.toLowerCase() + ' '))	×
134	return c.slice(fname.toLowerCase().length + 1);	×
UNCOV 135	return c;	×
136	});
137	}
138
139	// copy base canonical if property canonical is missing
UNCOV 140	if (canonical.base && !canonical.property)	×
UNCOV 141	canonical.property = [...canonical.base];	×
142
UNCOV 143	let typestr = typeToEntityType(func.getArgType(arg.name));	×
144
UNCOV 145	if (typestr && typeCounts[typestr] === 1) {	×
146	// if an entity is unique, allow dropping the property name entirely
UNCOV 147	if (!this.functions.includes(typestr.substring(typestr.indexOf(':') + 1)))	×
UNCOV 148	canonical.property.push('#');	×
149
150	// if it's the only people entity, adding adjective form
151	// E.g., author for review - bob's review
152	// byArtist for MusicRecording - bob's song
UNCOV 153	if (typestr.endsWith(':Person'))	×
UNCOV 154	canonical.adjective = ["# 's", '#'];	×
155	}
156
157	// if property is missing, try to use entity type info
UNCOV 158	if (!('property' in canonical)) {	×
159	// only apply this if there is only one property uses this entity type
160	if (typestr && typeCounts[typestr] === 1) {	×
161	let base = utils.clean(typestr.substring(typestr.indexOf(':') + 1));	×
162	canonical['property'] = [base];	×
163	canonical['base'] = [base];	×
164	}
165	}
NEW 166	argobj['canonicals'] = canonical;	×
167
UNCOV 168	const samples = this._retrieveSamples(fname, arg);	×
NEW 169	if (samples)	×
UNCOV 170	argobj['values'] = samples;	×
171
NEW 172	functions[fname]['args'][arg.name] = argobj;	×
173	}
174	}
175
UNCOV 176	if (this.algorithm.length > 0) {	×
UNCOV 177	const args = [path.resolve(path.dirname(module.filename), './bert-canonical-annotator.py'), 'all'];	×
UNCOV 178	if (this.is_paraphraser)	×
179	args.push('--is-paraphraser');	×
UNCOV 180	if (this.gpt2_ordering)	×
181	args.push('--gpt2-ordering');	×
UNCOV 182	if (this.pruning) {	×
UNCOV 183	args.push('--pruning-threshold');	×
UNCOV 184	args.push(this.pruning);	×
185	}
UNCOV 186	args.push('--model-name-or-path');	×
UNCOV 187	args.push(this.model);	×
UNCOV 188	args.push(this.mask ? '--mask' : '--no-mask');	×
189
190	// call bert to generate candidates
UNCOV 191	const child = child_process.spawn(`python3`, args, {stdio: ['pipe', 'pipe', 'inherit']});	×
192
UNCOV 193	const output = util.promisify(fs.writeFile);	×
UNCOV 194	if (this.options.debug)	×
195	await output(`./bert-canonical-annotator-in.json`, JSON.stringify(functions, null, 2));	×
196
UNCOV 197	const stdout = await new Promise((resolve, reject) => {	×
UNCOV 198	child.stdin.write(JSON.stringify(functions));	×
UNCOV 199	child.stdin.end();	×
UNCOV 200	child.on('error', reject);	×
UNCOV 201	child.stdout.on('error', reject);	×
UNCOV 202	child.stdout.setEncoding('utf8');	×
UNCOV 203	let buffer = '';	×
UNCOV 204	child.stdout.on('data', (data) => {	×
UNCOV 205	buffer += data;	×
206	});
UNCOV 207	child.stdout.on('end', () => resolve(buffer));	×
208	});
209
UNCOV 210	if (this.options.debug) {	×
211	try {	×
212	await output(`./bert-canonical-annotator-out.json`, JSON.stringify(JSON.parse(stdout), null, 2));	×
213	} catch (e) {
214	await output(`./bert-canonical-annotator-out.json`, stdout);	×
215	}
216	}
217
UNCOV 218	const {synonyms, adjectives } = JSON.parse(stdout);	×
UNCOV 219	if (this.algorithm.includes('bert') \|\| this.algorithm.includes('adj'))	×
UNCOV 220	this._updateCanonicals(synonyms, adjectives);	×
UNCOV 221	if (this.algorithm.includes('bart')) {	×
UNCOV 222	const extractor = new CanonicalExtractor(this.class, this.functions, this.paraphraser_model, this.options);	×
UNCOV 223	await extractor.run(synonyms, functions);	×
224	}
225	}
226
UNCOV 227	return this.class;	×
228	}
229
230	_getArgTypeCount(schema) {
UNCOV 231	const count = {};	×
UNCOV 232	for (let arg of schema.iterateArguments()) {	×
UNCOV 233	let typestr = typeToEntityType(schema.getArgType(arg.name));	×
UNCOV 234	if (!typestr)	×
UNCOV 235	continue;	×
UNCOV 236	count[typestr] = (count[typestr] \|\| 0) + 1;	×
237	}
UNCOV 238	return count;	×
239	}
240
241	async _loadParameterDatasetPaths() {
UNCOV 242	const rows = (await (util.promisify(fs.readFile))(this.parameterDatasets, { encoding: 'utf8' })).split('\n');	×
UNCOV 243	for (let row of rows) {	×
UNCOV 244	let [type, /locale/, key, path] = row.split('\t');	×
UNCOV 245	this.parameterDatasetPaths[key] = [type, path];	×
246	}
247	}
248
249	_getDatasetPath(qname, arg) {
UNCOV 250	const keys = [];	×
UNCOV 251	const stringValueAnnotation = arg.getImplementationAnnotation('string_values');	×
UNCOV 252	if (stringValueAnnotation)	×
UNCOV 253	keys.push(stringValueAnnotation);	×
UNCOV 254	keys.push(`${this.class.kind}:${qname}_${arg.name}`);	×
UNCOV 255	const elementType = arg.type.isArray ? arg.type.elem : arg.type;	×
UNCOV 256	if (!elementType.isCompound)	×
UNCOV 257	keys.push(elementType.isEntity ? elementType.type : elementType);	×
258
UNCOV 259	for (let key of keys) {	×
UNCOV 260	if (this.parameterDatasetPaths[key])	×
UNCOV 261	return this.parameterDatasetPaths[key];	×
262	}
UNCOV 263	return null;	×
264	}
265
266	_updateCanonicals(candidates, adjectives) {
UNCOV 267	for (let fname of this.functions) {	×
UNCOV 268	let func = this.class.queries[fname] \|\| this.class.actions[fname];	×
UNCOV 269	for (let arg in candidates[fname]) {	×
UNCOV 270	if (arg === 'id')	×
UNCOV 271	continue;	×
UNCOV 272	let canonicals = func.getArgument(arg).metadata.canonical;	×
UNCOV 273	if (!canonicals)	×
274	throw new Error(`Missing canonical form for ${arg} in @${func.class.name}.${func.name}`);	×
UNCOV 275	if (typeof canonicals === 'string')	×
276	canonicals = { base: [canonicals] };	×
UNCOV 277	else if (Array.isArray(canonicals))	×
278	canonicals = { base: canonicals };	×
279
UNCOV 280	if (this.algorithm.includes('adj') && adjectives.includes(`${fname}.${arg}`))	×
UNCOV 281	canonicals['adjective'] = ['#'];	×
282
UNCOV 283	if (this.algorithm.includes('bert')) {	×
UNCOV 284	for (let type in candidates[fname][arg]) {	×
UNCOV 285	for (let candidate in candidates[fname][arg][type]) {	×
UNCOV 286	if (this._hasConflict(fname, arg, type, candidate))	×
UNCOV 287	continue;	×
UNCOV 288	if (type === 'reverse_verb' && !this._isVerb(candidate))	×
UNCOV 289	continue;	×
UNCOV 290	if (!canonicals[type].includes(candidate))	×
UNCOV 291	canonicals[type].push(candidate);	×
292	}
293	}
294
UNCOV 295	if (canonicals.reverse_verb && canonicals.reverse_verb.length === 1) {	×
296	// FIXME: a hack, when there is only one candidate for reverse verb, it means the inflector noun
297	// to verb doesn't work, add the following heuristics
298	const base = (new Inflectors(canonicals.base[0])).toSingular();	×
299	if (base.endsWith('or') \|\| base.endsWith('er'))	×
300	canonicals.reverse_verb.push(base.slice(0, -2) + 'ed');	×
301	canonicals.reverse_verb.push(base);	×
302	}
303	}
304	}
305	}
306	}
307
308	_isVerb(candidate) {
UNCOV 309	if (candidate === 'is' \|\| candidate === 'are')	×
310	return false;	×
311
UNCOV 312	return ['VBP', 'VBZ', 'VBD'].includes(this._langPack.posTag([candidate])[0]);	×
313	}
314
315	_hasConflict(fname, currentArg, currentPos, currentCanonical) {
UNCOV 316	const func = this.class.queries[fname] \|\| this.class.actions[fname];	×
UNCOV 317	currentArg = func.getArgument(currentArg);	×
UNCOV 318	const currentStringset = currentArg.getImplementationAnnotation('string_values');	×
UNCOV 319	for (let arg of func.iterateArguments()) {	×
UNCOV 320	if (arg.name === currentArg.name)	×
UNCOV 321	continue;	×
322
323	// for non base, we only check conflict between arguments of the same type, or same string set
UNCOV 324	if (currentPos !== 'base') {	×
UNCOV 325	if (currentStringset) {	×
UNCOV 326	let stringset = arg.getImplementationAnnotation('string_values');	×
UNCOV 327	if (stringset && stringset !== currentStringset)	×
UNCOV 328	continue;	×
329	}
UNCOV 330	let currentType = currentArg.type.isArray ? currentArg.type.elem : currentArg.type;	×
UNCOV 331	let type = arg.type.isArray ? arg.type.elem : arg.type;	×
UNCOV 332	if (!currentType.equals(type))	×
UNCOV 333	continue;	×
334	}
335
UNCOV 336	const canonicals = arg.metadata.canonical;	×
337
UNCOV 338	for (let pos in canonicals) {	×
339	// if current pos is base, only check base
UNCOV 340	if (currentPos === 'base' && pos !== 'base')	×
UNCOV 341	continue;	×
342	// if current pos is not base, only check non-base
UNCOV 343	if (currentPos !== 'base' && pos === 'base')	×
344	continue;	×
UNCOV 345	let conflictFound = false;	×
UNCOV 346	let todelete = [];	×
UNCOV 347	for (let i = 0; i < canonicals[pos].length; i++) {	×
UNCOV 348	let canonical = canonicals[pos][i];	×
UNCOV 349	if (stemmer(canonical) === stemmer(currentCanonical)) {	×
350	// conflict with the base canonical phrase of another parameter, return true directly
UNCOV 351	if (i === 0)	×
UNCOV 352	return true;	×
353	// conflict with generate canonicals of another parameter, remove conflicts, then return true
UNCOV 354	conflictFound = true;	×
UNCOV 355	todelete.push(canonical);	×
356	}
357	}
UNCOV 358	if (conflictFound) {	×
UNCOV 359	for (let canonical of todelete) {	×
UNCOV 360	let index = canonicals[pos].indexOf(canonical);	×
UNCOV 361	canonicals[pos].splice(index, 1);	×
362	}
UNCOV 363	return true;	×
364	}
365	}
366	}
367
368	//TODO: also consider conflicts between candidates
369
UNCOV 370	return false;	×
371	}
372
373	_retrieveSamples(qname, arg) {
374	//TODO: also use enum canonicals?
NEW 375	if (arg.type.isEnum)	×
NEW 376	return arg.type.entries.slice(0, 10).map(clean);	×
377
UNCOV 378	const keys = makeLookupKeys('@' + this.class.kind + '.' + qname, arg.name, arg.type);	×
379	let samples;
UNCOV 380	for (let key of keys) {	×
UNCOV 381	if (this.constants[key]) {	×
UNCOV 382	samples = this.constants[key];	×
UNCOV 383	break;	×
384	}
385	}
UNCOV 386	if (samples) {	×
UNCOV 387	samples = samples.map((v) => {	×
UNCOV 388	if (arg.type.isString \|\| (arg.type.isArray && arg.type.elem.isString))	×
UNCOV 389	return v.value;	×
UNCOV 390	return v.display;	×
391	});
392	}
UNCOV 393	return samples;	×
394	}
395	}
396
397	module.exports = AutoCanonicalGenerator;	26✔

stanford-oval / genie-toolkit / 1020

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