stanford-oval / genie-toolkit / 773

pending completion

Build # 773

Build Type

Pull #162

travis-ci-com

Committed by

web-flow

Commit Message

Merge bb3fee494 into 980c444af

Pull Request Pull Request #162: Wip/multilanguage

Run Details

1360 of 4788 branches covered (28.4%)

Branch coverage included in aggregate %.

25 of 64 new or added lines in 11 files covered. (39.06%)

121 existing lines in 4 files now uncovered.

4089 of 9644 relevant lines covered (42.4%)

17353.35 hits per line

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

87.78

/tool/requote.js

// -*- mode: js; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of Genie
//
// Copyright 2019 The Board of Trustees of the Leland Stanford Junior University
//
// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>,
//          Mehrad Moradshahi <mehrad@cs.stanford.edu>
//
// See COPYING for details
"use strict";

const fs = require('fs');
const Stream = require('stream');
const assert = require('assert');

const { DatasetParser, DatasetStringifier } = require('../lib/dataset-parsers');
const { maybeCreateReadStream, readAllLines } = require('./lib/argutils');
const StreamUtils = require('../lib/stream-utils');

const ENTITY_MATCH_REGEX = /^([A-Z].*)_[0-9]+$/;
const NUMBER_MATCH_REGEX = /^([0-9]+)$/;
const SMALL_NUMBER_REGEX = /^-?10|11|12|[0-9]$/;

function do_replace_numbers(token, requote_numbers) {
    // 1) check if token is an Arabic or English number
    // 2) ignore "small numbers" ranging from -12 to 12

    return requote_numbers && NUMBER_MATCH_REGEX.test(token) && !(SMALL_NUMBER_REGEX.exec(token)[0] === token);
}

function findSpanContaining(index, spansBySentencePos) {
    for (let i = 0; i < spansBySentencePos.length; i++) {
        const span = spansBySentencePos[i];
        if (index >= span.begin && index < span.end)
            return span;
    }
    return undefined;
}


function findSubstring(sequence, substring, spansBySentencePos, allowOverlapping) {
    for (let i = 0; i < sequence.length - substring.length + 1; i++) {
        let found = true;

        for (let j = 0; j < substring.length; j++) {
            if (sequence[i+j] !== substring[j]) {
                found = false;
                break;
            }
        }
        if (found && (allowOverlapping || !findSpanContaining(i, spansBySentencePos)))
            return i;
    }
    return -1;
}


function findSpanType(program, begin_index, end_index, requote_numbers, string_number = false) {
    let spanType;
    if (begin_index > 1 && program[begin_index-2] === 'location:') {
        spanType = 'LOCATION';

    } else if (do_replace_numbers(program[begin_index], requote_numbers) && !(program[end_index+1].startsWith('^^'))){
        // catch purely numeric postal_codes or phone_numbers
        if (string_number)
            spanType = 'QUOTED_STRING';
        else
            spanType = 'NUMBER';
    } else if (end_index === program.length - 1 || !program[end_index+1].startsWith('^^')) {
        spanType = 'QUOTED_STRING';
    } else {
        switch (program[end_index+1]) {
        case '^^tt:hashtag':
            spanType = 'HASHTAG';
            break;
        case '^^tt:username':
            spanType = 'USERNAME';
            break;
        case '^^tt:phone_number':
            spanType = 'PHONE_NUMBER';
            break;
        default:
            spanType = 'GENERIC_ENTITY_' + program[end_index+1].substring(2);
        }
    }
    return spanType;
}


function createProgram(program, spansByProgramPos, entityRemap, requote_numbers) {
    let in_string = false;
    let newProgram = [];
    let programSpanIndex = 0;

    for (let i = 0; i < program.length; i++) {
        let token = program[i];
        if (token === '"') {
            in_string = !in_string;
            if (in_string)
                continue;
            const currentSpan = spansByProgramPos[programSpanIndex];
            if (!currentSpan.sentenceSpan || !currentSpan.sentenceSpan.mapTo)
                console.log(spansByProgramPos);
            assert(currentSpan.sentenceSpan.mapTo);

            newProgram.push(currentSpan.sentenceSpan.mapTo);
            programSpanIndex++;
            continue;
        }
        if (in_string)
            continue;
        if (token === 'location:' || token.startsWith('^^')) {
            continue;
        } else if (ENTITY_MATCH_REGEX.test(token)) {
            assert(entityRemap[token]);
            newProgram.push(entityRemap[token]);
        } else if (do_replace_numbers(token, requote_numbers)){
            const currentSpan = spansByProgramPos[programSpanIndex];
            newProgram.push(currentSpan.sentenceSpan.mapTo);
            programSpanIndex++;
        } else {
            newProgram.push(token);
        }
    }
    return newProgram;
}

function qpisSentence(sentence, spansBySentencePos) {

    let current_span_idx = 0;
    let current_span = spansBySentencePos[0];

    let newSentence = [];
    let i = 0;
    let in_string = false;
    while (i < sentence.length) {
        let word = sentence[i];
        if (current_span === null || i < current_span.begin) {
            newSentence.push(word);
            i += 1;
        } else if (i >= current_span.end) {
            newSentence.push('"');
            in_string = false;
            current_span_idx += 1;
            current_span = current_span_idx < spansBySentencePos.length ? spansBySentencePos[current_span_idx] : null;
        } else if (i === current_span.begin || in_string) {
            if (i === current_span.begin)
                newSentence.push('"');
            newSentence.push(word);
            in_string = true;
            i += 1;

        } else {
            i += 1;
        }
    }
    if (in_string)
        newSentence.push('"');
    return newSentence;

}

function createSentence(sentence, contextEntities, spansBySentencePos) {

    let current_span_idx = 0;
    let current_span = spansBySentencePos[0];

    let newSentence = [];
    let entityNumbers = {};
    let entityRemap = {};
    for (let entity of contextEntities) {
        const [, type, num] = /^(.+)_([0-9]+)$/.exec(entity);
        entityNumbers[type] = Math.max(num+1, entityNumbers[type] || 0);
        entityRemap[entity] = entity;
    }

    function getEntityNumber(entityType) {
        let nextId = (entityNumbers[entityType] || 0);
        entityNumbers[entityType] = nextId + 1;
        return String(nextId);
    }

    let i = 0;
    while (i < sentence.length) {
        let word = sentence[i];
        if (current_span === null || i < current_span.begin) {
            const entityMatch = ENTITY_MATCH_REGEX.exec(word);
            if (entityMatch !== null) {
                // input sentence contains entities
                const newEntity = entityMatch[1] + '_' + getEntityNumber(entityMatch[1]);
                entityRemap[word] = newEntity;
                newSentence.push(newEntity);
            } else {
                newSentence.push(word);
            }
            i += 1;
        } else if (i === current_span.begin) {
            const newEntity = current_span.type + '_' + getEntityNumber(current_span.type);
            current_span.mapTo = newEntity;
            newSentence.push(newEntity);
            i += 1;
        } else if (i >= current_span.end) {
            current_span_idx += 1;
            current_span = current_span_idx < spansBySentencePos.length ? spansBySentencePos[current_span_idx] : null;
        } else {
            i += 1;
        }
    }

    return [newSentence, entityRemap];

}


function getProgSpans(program, requote_numbers) {
    let in_string = false;
    let begin_index = null;
    let end_index = null;
    let span_type = null;
    let allProgSpans = [];
    for (let i = 0; i < program.length; i++) {
        let token = program[i];
        if (token === '"') {
            in_string = !in_string;
            if (in_string) {
                begin_index = i + 1;
            } else {
                end_index = i;
                span_type = findSpanType(program, begin_index, end_index, requote_numbers, true);
                let prog_span = {begin: begin_index, end: end_index, span_type:span_type};
                allProgSpans.push(prog_span);
            }
        } else if (!in_string && do_replace_numbers(token, requote_numbers)){
            begin_index = i;
            end_index = begin_index + 1;
            span_type = findSpanType(program, begin_index, end_index, requote_numbers);
            let prog_span = {begin: begin_index, end: end_index, span_type:span_type};
            allProgSpans.push(prog_span);
        }
    }

    // sort params based on length so that longer phrases get matched sooner
    allProgSpans.sort((a, b) => {
        const { begin:abegin, end:aend } = a;
        const { begin:bbegin, end:bend } = b;
        return (bend - bbegin) - (aend - abegin);
    });
    return allProgSpans;
}


function findSpanPositions(id, sentence, program, requote_numbers) {
    const spansBySentencePos = [];
    const spansByProgramPos = [];

    // allProgSpans is sorted by length (longest first)
    const allProgSpans = getProgSpans(program, requote_numbers);

    for (const progSpan of allProgSpans) {
        let [begin_index, end_index, span_type] = [progSpan.begin, progSpan.end, progSpan.span_type];
        const substring = program.slice(begin_index, end_index);


        // first try without overlapping parameters, then try with overlapping parameters
        // (this is mostly useful for parameters that used twice, which happens in some dialogue dataset)
        let idx = findSubstring(sentence, substring, spansBySentencePos, false /* allow overlapping */);
        if (idx < 0) {
            idx = findSubstring(sentence, substring, spansBySentencePos, true /* allow overlapping */);

            if (idx < 0) {
                console.log(program.join(' '));
                throw new Error(`Cannot find span ${substring.join(' ')} in sentence id ${id}`);
            } else {
                const overlappingSpan = findSpanContaining(idx, spansBySentencePos);
                assert(overlappingSpan);
                if (idx !== overlappingSpan.begin || idx + end_index - begin_index !== overlappingSpan.end)
                    throw new Error(`Found span ${substring.join(' ')} that overlaps another span but is not identical in sentence id ${id}`);

                // otherwise, the two spans are identical, so we don't create a new span
                spansByProgramPos.push({
                    begin: begin_index,
                    end: end_index,
                    sentenceSpan: overlappingSpan
                });
                continue;
            }
        }

        const sentenceSpanBegin = idx;
        const sentenceSpanEnd = idx + end_index - begin_index;
        const spanType = span_type;

        const sentenceSpan = { begin: sentenceSpanBegin, end: sentenceSpanEnd, type: spanType, mapTo: undefined };
        spansBySentencePos.push(sentenceSpan);
        spansByProgramPos.push({
            begin: begin_index,
            end: end_index,
            sentenceSpan: sentenceSpan
        });
    }

    // sort by program position after matching is done
    spansByProgramPos.sort((a, b) => {
        return a.begin - b.begin;
    });
    return [spansBySentencePos, spansByProgramPos];
}


function requoteSentence(id, context, sentence, program, mode, requote_numbers) {
    sentence = sentence.split(' ');
    program = program.split(' ');

    let contextEntities = new Set;
    if (context) {
        for (let token of context.split(' ')) {
            if (/^[A-Z]/.test(token))
                contextEntities.add(token);
        }
    }

    let [spansBySentencePos, spansByProgramPos] = findSpanPositions(id, sentence, program, requote_numbers);

    if (spansBySentencePos.length === 0)
        return [sentence.join(' '), program.join(' ')];

    spansBySentencePos.sort((a, b) => {
        const {begin:abegin, end:aend} = a;
        const {begin:bbegin, end:bend} = b;
        if (abegin < bbegin)
            return -1;
        if (bbegin < abegin)
            return +1;
        if (aend < bend)
            return -1;
        if (bend < aend)
            return +1;
        return 0;
    });

    let newSentence, newProgram, entityRemap;

    if (mode === 'replace'){
        [newSentence, entityRemap] = createSentence(sentence, contextEntities, spansBySentencePos);
        newProgram = createProgram(program, spansByProgramPos, entityRemap, requote_numbers);
    } else if (mode === 'qpis') {
        newSentence = qpisSentence(sentence, spansBySentencePos);
        newProgram = program;
    }

    return [newSentence.join(' '), newProgram.join(' ')];
}


module.exports = {
    initArgparse(subparsers) {
        const parser = subparsers.addParser('requote', {
            addHelp: true,
            description: "Requote a dataset."
        });
        parser.addArgument(['-o', '--output'], {
            required: true,
            type: fs.createWriteStream
        });
        parser.addArgument('--contextual', {
            nargs: 0,
            action: 'storeTrue',
            help: 'Process a contextual dataset.',
            defaultValue: false
        });
        parser.addArgument('--mode', {
            type: String,
            help: 'Type of requoting (replace with placeholder, or just add quotation marks around params)',
            choices: ['replace', 'qpis'],
            defaultValue: 'replace'
        });
        parser.addArgument('--requote_numbers', {
            action: 'storeTrue',
            help: 'Requote numbers',
            defaultValue: false
        });
        parser.addArgument('--skip_errors', {
            action: 'storeTrue',
            help: 'Skip examples that we are unable to requote',
            defaultValue: false
        });
        parser.addArgument('input_file', {
            nargs: '+',
            type: maybeCreateReadStream,
            help: 'Input datasets to evaluate (in TSV format); use - for standard input'
        });
    },

    async execute(args) {
        readAllLines(args.input_file)
            .pipe(new DatasetParser({ contextual: args.contextual }))
            .pipe(new Stream.Transform({
                objectMode: true,

                transform(ex, encoding, callback) {
                    try {
                        const [newSentence, newProgram] =
                            requoteSentence(ex.id, ex.context, ex.preprocessed, ex.target_code, args.mode, args.requote_numbers);
                        ex.preprocessed = newSentence;
                        ex.target_code = newProgram;
                        callback(null, ex);
                    } catch(e) {
                        console.error(`Failed to requote`);
                        console.error(ex.id);
                        console.error(ex.preprocessed);
                        console.error(ex.target_code);
                        if (args.skip_errors)
                            callback(null);
                        else
                            callback(e);
                        
                    }
                },

                flush(callback) {
                    process.nextTick(callback);
                }
            }))
            .pipe(new DatasetStringifier())
            .pipe(args.output);

        await StreamUtils.waitFinish(args.output);
    }
};

1	// -- mode: js; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of Genie
4	//
5	// Copyright 2019 The Board of Trustees of the Leland Stanford Junior University
6	//
7	// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>,
8	// Mehrad Moradshahi <mehrad@cs.stanford.edu>
9	//
10	// See COPYING for details
11	"use strict";
12
13	const fs = require('fs');	52✔
14	const Stream = require('stream');	52✔
15	const assert = require('assert');	52✔
16
17	const { DatasetParser, DatasetStringifier } = require('../lib/dataset-parsers');	52✔
18	const { maybeCreateReadStream, readAllLines } = require('./lib/argutils');	52✔
19	const StreamUtils = require('../lib/stream-utils');	52✔
20
21	const ENTITY_MATCH_REGEX = /^([A-Z].*)_[0-9]+$/;	52✔
22	const NUMBER_MATCH_REGEX = /^([0-9]+)$/;	52✔
23	const SMALL_NUMBER_REGEX = /^-?10\|11\|12\|[0-9]$/;	52✔
24
25	function do_replace_numbers(token, requote_numbers) {
26	// 1) check if token is an Arabic or English number
27	// 2) ignore "small numbers" ranging from -12 to 12
28
29	return requote_numbers && NUMBER_MATCH_REGEX.test(token) && !(SMALL_NUMBER_REGEX.exec(token)[0] === token);	563,930✔
30	}
31
32	function findSpanContaining(index, spansBySentencePos) {
33	for (let i = 0; i < spansBySentencePos.length; i++) {	14,196✔
34	const span = spansBySentencePos[i];	2,904✔
35	if (index >= span.begin && index < span.end)	2,904✔
36	return span;	20✔
37	}
38	return undefined;	14,176✔
39	}
40
41
42	function findSubstring(sequence, substring, spansBySentencePos, allowOverlapping) {
43	for (let i = 0; i < sequence.length - substring.length + 1; i++) {	14,184✔
44	let found = true;	142,878✔
45
46	for (let j = 0; j < substring.length; j++) {	142,878✔
47	if (sequence[i+j] !== substring[j]) {	149,562✔
48	found = false;	128,682✔
49	break;	128,682✔
50	}
51	}
52	if (found && (allowOverlapping \|\| !findSpanContaining(i, spansBySentencePos)))	142,878✔
53	return i;	14,180✔
54	}
55	return -1;	4✔
56	}
57
58
59	function findSpanType(program, begin_index, end_index, requote_numbers, string_number = false) {	5,404✔
60	let spanType;
61	if (begin_index > 1 && program[begin_index-2] === 'location:') {	14,180✔
62	spanType = 'LOCATION';	230✔
63
64	} else if (do_replace_numbers(program[begin_index], requote_numbers) && !(program[end_index+1].startsWith('^^'))){	13,950✔
65	// catch purely numeric postal_codes or phone_numbers
66	if (string_number)	6,300✔
67	spanType = 'QUOTED_STRING';	896✔
68	else
69	spanType = 'NUMBER';	5,404✔
70	} else if (end_index === program.length - 1 \|\| !program[end_index+1].startsWith('^^')) {	7,650✔
71	spanType = 'QUOTED_STRING';	5,676✔
72	} else {
73	switch (program[end_index+1]) {	1,974!
74	case '^^tt:hashtag':
75	spanType = 'HASHTAG';	×
76	break;	×
77	case '^^tt:username':
78	spanType = 'USERNAME';	44✔
79	break;	44✔
80	case '^^tt:phone_number':
81	spanType = 'PHONE_NUMBER';	646✔
82	break;	646✔
83	default:
84	spanType = 'GENERIC_ENTITY_' + program[end_index+1].substring(2);	1,284✔
85	}
86	}
87	return spanType;	14,180✔
88	}
89
90
91	function createProgram(program, spansByProgramPos, entityRemap, requote_numbers) {
92	let in_string = false;	11,282✔
93	let newProgram = [];	11,282✔
94	let programSpanIndex = 0;	11,282✔
95
96	for (let i = 0; i < program.length; i++) {	11,282✔
97	let token = program[i];	278,626✔
98	if (token === '"') {	278,626✔
99	in_string = !in_string;	17,444✔
100	if (in_string)	17,444✔
101	continue;	8,722✔
102	const currentSpan = spansByProgramPos[programSpanIndex];	8,722✔
103	if (!currentSpan.sentenceSpan \|\| !currentSpan.sentenceSpan.mapTo)	8,722!
104	console.log(spansByProgramPos);	×
105	assert(currentSpan.sentenceSpan.mapTo);	8,722✔
106
107	newProgram.push(currentSpan.sentenceSpan.mapTo);	8,722✔
108	programSpanIndex++;	8,722✔
109	continue;	8,722✔
110	}
111	if (in_string)	261,182✔
112	continue;	15,300✔
113	if (token === 'location:' \|\| token.startsWith('^^')) {	245,882✔
114	continue;	2,194✔
115	} else if (ENTITY_MATCH_REGEX.test(token)) {	243,688✔
116	assert(entityRemap[token]);	346✔
117	newProgram.push(entityRemap[token]);	346✔
118	} else if (do_replace_numbers(token, requote_numbers)){	243,342✔
119	const currentSpan = spansByProgramPos[programSpanIndex];	5,404✔
120	newProgram.push(currentSpan.sentenceSpan.mapTo);	5,404✔
121	programSpanIndex++;	5,404✔
122	} else {
123	newProgram.push(token);	237,938✔
124	}
125	}
126	return newProgram;	11,282✔
127	}
128
129	function qpisSentence(sentence, spansBySentencePos) {
130
131	let current_span_idx = 0;	26✔
132	let current_span = spansBySentencePos[0];	26✔
133
134	let newSentence = [];	26✔
135	let i = 0;	26✔
136	let in_string = false;	26✔
137	while (i < sentence.length) {	26✔
138	let word = sentence[i];	358✔
139	if (current_span === null \|\| i < current_span.begin) {	358✔
140	newSentence.push(word);	220✔
141	i += 1;	220✔
142	} else if (i >= current_span.end) {	138✔
143	newSentence.push('"');	44✔
144	in_string = false;	44✔
145	current_span_idx += 1;	44✔
146	current_span = current_span_idx < spansBySentencePos.length ? spansBySentencePos[current_span_idx] : null;	44✔
147	} else if (i === current_span.begin \|\| in_string) {	94!
148	if (i === current_span.begin)	94✔
149	newSentence.push('"');	52✔
150	newSentence.push(word);	94✔
151	in_string = true;	94✔
152	i += 1;	94✔
153
154	} else {
155	i += 1;	×
156	}
157	}
158	if (in_string)	26✔
159	newSentence.push('"');	8✔
160	return newSentence;	26✔
161
162	}
163
164	function createSentence(sentence, contextEntities, spansBySentencePos) {
165
166	let current_span_idx = 0;	11,282✔
167	let current_span = spansBySentencePos[0];	11,282✔
168
169	let newSentence = [];	11,282✔
170	let entityNumbers = {};	11,282✔
171	let entityRemap = {};	11,282✔
172	for (let entity of contextEntities) {	11,282✔
173	const [, type, num] = /^(.+)_([0-9]+)$/.exec(entity);	×
174	entityNumbers[type] = Math.max(num+1, entityNumbers[type] \|\| 0);	×
175	entityRemap[entity] = entity;	×
176	}
177
178	function getEntityNumber(entityType) {
179	let nextId = (entityNumbers[entityType] \|\| 0);	14,478✔
180	entityNumbers[entityType] = nextId + 1;	14,478✔
181	return String(nextId);	14,478✔
182	}
183
184	let i = 0;	11,282✔
185	while (i < sentence.length) {	11,282✔
186	let word = sentence[i];	179,730✔
187	if (current_span === null \|\| i < current_span.begin) {	179,730✔
188	const entityMatch = ENTITY_MATCH_REGEX.exec(word);	146,830✔
189	if (entityMatch !== null) {	146,830✔
190	// input sentence contains entities
191	const newEntity = entityMatch[1] + '_' + getEntityNumber(entityMatch[1]);	354✔
192	entityRemap[word] = newEntity;	354✔
193	newSentence.push(newEntity);	354✔
194	} else {
195	newSentence.push(word);	146,476✔
196	}
197	i += 1;	146,830✔
198	} else if (i === current_span.begin) {	32,900✔
199	const newEntity = current_span.type + '_' + getEntityNumber(current_span.type);	14,124✔
200	current_span.mapTo = newEntity;	14,124✔
201	newSentence.push(newEntity);	14,124✔
202	i += 1;	14,124✔
203	} else if (i >= current_span.end) {	18,776✔
204	current_span_idx += 1;	12,198✔
205	current_span = current_span_idx < spansBySentencePos.length ? spansBySentencePos[current_span_idx] : null;	12,198✔
206	} else {
207	i += 1;	6,578✔
208	}
209	}
210
211	return [newSentence, entityRemap];	11,282✔
212
213	}
214
215
216	function getProgSpans(program, requote_numbers) {
217	let in_string = false;	13,950✔
218	let begin_index = null;	13,950✔
219	let end_index = null;	13,950✔
220	let span_type = null;	13,950✔
221	let allProgSpans = [];	13,950✔
222	for (let i = 0; i < program.length; i++) {	13,950✔
223	let token = program[i];	339,586✔
224	if (token === '"') {	339,586✔
225	in_string = !in_string;	17,552✔
226	if (in_string) {	17,552✔
227	begin_index = i + 1;	8,776✔
228	} else {
229	end_index = i;	8,776✔
230	span_type = findSpanType(program, begin_index, end_index, requote_numbers, true);	8,776✔
231	let prog_span = {begin: begin_index, end: end_index, span_type:span_type};	8,776✔
232	allProgSpans.push(prog_span);	8,776✔
233	}
234	} else if (!in_string && do_replace_numbers(token, requote_numbers)){	322,034✔
235	begin_index = i;	5,404✔
236	end_index = begin_index + 1;	5,404✔
237	span_type = findSpanType(program, begin_index, end_index, requote_numbers);	5,404✔
238	let prog_span = {begin: begin_index, end: end_index, span_type:span_type};	5,404✔
239	allProgSpans.push(prog_span);	5,404✔
240	}
241	}
242
243	// sort params based on length so that longer phrases get matched sooner
244	allProgSpans.sort((a, b) => {	13,950✔
245	const { begin:abegin, end:aend } = a;	2,884✔
246	const { begin:bbegin, end:bend } = b;	2,884✔
247	return (bend - bbegin) - (aend - abegin);	2,884✔
248	});
249	return allProgSpans;	13,950✔
250	}
251
252
253	function findSpanPositions(id, sentence, program, requote_numbers) {
254	const spansBySentencePos = [];	13,950✔
255	const spansByProgramPos = [];	13,950✔
256
257	// allProgSpans is sorted by length (longest first)
258	const allProgSpans = getProgSpans(program, requote_numbers);	13,950✔
259
260	for (const progSpan of allProgSpans) {	13,950✔
261	let [begin_index, end_index, span_type] = [progSpan.begin, progSpan.end, progSpan.span_type];	14,180✔
262	const substring = program.slice(begin_index, end_index);	14,180✔
263
264
265	// first try without overlapping parameters, then try with overlapping parameters
266	// (this is mostly useful for parameters that used twice, which happens in some dialogue dataset)
267	let idx = findSubstring(sentence, substring, spansBySentencePos, false /* allow overlapping */);	14,180✔
268	if (idx < 0) {	14,180✔
269	idx = findSubstring(sentence, substring, spansBySentencePos, true /* allow overlapping */);	4✔
270
271	if (idx < 0) {	4!
272	console.log(program.join(' '));	×
273	throw new Error(`Cannot find span ${substring.join(' ')} in sentence id ${id}`);	×
274	} else {
275	const overlappingSpan = findSpanContaining(idx, spansBySentencePos);	4✔
276	assert(overlappingSpan);	4✔
277	if (idx !== overlappingSpan.begin \|\| idx + end_index - begin_index !== overlappingSpan.end)	4!
278	throw new Error(`Found span ${substring.join(' ')} that overlaps another span but is not identical in sentence id ${id}`);	×
279
280	// otherwise, the two spans are identical, so we don't create a new span
281	spansByProgramPos.push({	4✔
282	begin: begin_index,
283	end: end_index,
284	sentenceSpan: overlappingSpan
285	});
286	continue;	4✔
287	}
288	}
289
290	const sentenceSpanBegin = idx;	14,176✔
291	const sentenceSpanEnd = idx + end_index - begin_index;	14,176✔
292	const spanType = span_type;	14,176✔
293
294	const sentenceSpan = { begin: sentenceSpanBegin, end: sentenceSpanEnd, type: spanType, mapTo: undefined };	14,176✔
295	spansBySentencePos.push(sentenceSpan);	14,176✔
296	spansByProgramPos.push({	14,176✔
297	begin: begin_index,
298	end: end_index,
299	sentenceSpan: sentenceSpan
300	});
301	}
302
303	// sort by program position after matching is done
304	spansByProgramPos.sort((a, b) => {	13,950✔
305	return a.begin - b.begin;	2,884✔
306	});
307	return [spansBySentencePos, spansByProgramPos];	13,950✔
308	}
309
310
311	function requoteSentence(id, context, sentence, program, mode, requote_numbers) {
312	sentence = sentence.split(' ');	13,950✔
313	program = program.split(' ');	13,950✔
314
315	let contextEntities = new Set;	13,950✔
316	if (context) {	13,950!
317	for (let token of context.split(' ')) {	×
318	if (/^[A-Z]/.test(token))	×
319	contextEntities.add(token);	×
320	}
321	}
322
323	let [spansBySentencePos, spansByProgramPos] = findSpanPositions(id, sentence, program, requote_numbers);	13,950✔
324
325	if (spansBySentencePos.length === 0)	13,950✔
326	return [sentence.join(' '), program.join(' ')];	2,642✔
327
328	spansBySentencePos.sort((a, b) => {	11,308✔
329	const {begin:abegin, end:aend} = a;	2,882✔
330	const {begin:bbegin, end:bend} = b;	2,882✔
331	if (abegin < bbegin)	2,882✔
332	return -1;	1,440✔
333	if (bbegin < abegin)	1,442!
334	return +1;	1,442✔
335	if (aend < bend)	×
336	return -1;	×
337	if (bend < aend)	×
338	return +1;	×
339	return 0;	×
340	});
341
342	let newSentence, newProgram, entityRemap;
343
344	if (mode === 'replace'){	11,308✔
345	[newSentence, entityRemap] = createSentence(sentence, contextEntities, spansBySentencePos);	11,282✔
346	newProgram = createProgram(program, spansByProgramPos, entityRemap, requote_numbers);	11,282✔
347	} else if (mode === 'qpis') {	26!
348	newSentence = qpisSentence(sentence, spansBySentencePos);	26✔
349	newProgram = program;	26✔
350	}
351
352	return [newSentence.join(' '), newProgram.join(' ')];	11,308✔
353	}
354
355
356	module.exports = {	52✔
357	initArgparse(subparsers) {
358	const parser = subparsers.addParser('requote', {	52✔
359	addHelp: true,
360	description: "Requote a dataset."
361	});
362	parser.addArgument(['-o', '--output'], {	52✔
363	required: true,
364	type: fs.createWriteStream
365	});
366	parser.addArgument('--contextual', {	52✔
367	nargs: 0,
368	action: 'storeTrue',
369	help: 'Process a contextual dataset.',
370	defaultValue: false
371	});
372	parser.addArgument('--mode', {	52✔
373	type: String,
374	help: 'Type of requoting (replace with placeholder, or just add quotation marks around params)',
375	choices: ['replace', 'qpis'],
376	defaultValue: 'replace'
377	});
378	parser.addArgument('--requote_numbers', {	52✔
379	action: 'storeTrue',
380	help: 'Requote numbers',
381	defaultValue: false
382	});
383	parser.addArgument('--skip_errors', {	52✔
384	action: 'storeTrue',
385	help: 'Skip examples that we are unable to requote',
386	defaultValue: false
387	});
388	parser.addArgument('input_file', {	52✔
389	nargs: '+',
390	type: maybeCreateReadStream,
391	help: 'Input datasets to evaluate (in TSV format); use - for standard input'
392	});
393	},
394
395	async execute(args) {
396	readAllLines(args.input_file)	8✔
397	.pipe(new DatasetParser({ contextual: args.contextual }))
398	.pipe(new Stream.Transform({
399	objectMode: true,
400
401	transform(ex, encoding, callback) {
402	try {	13,950✔
403	const [newSentence, newProgram] =
404	requoteSentence(ex.id, ex.context, ex.preprocessed, ex.target_code, args.mode, args.requote_numbers);	13,950✔
405	ex.preprocessed = newSentence;	13,950✔
406	ex.target_code = newProgram;	13,950✔
407	callback(null, ex);	13,950✔
408	} catch(e) {
409	console.error(`Failed to requote`);	×
NEW 410	console.error(ex.id);	×
411	console.error(ex.preprocessed);	×
412	console.error(ex.target_code);	×
NEW 413	if (args.skip_errors)	×
NEW 414	callback(null);	×
415	else
NEW 416	callback(e);	×
417
418	}
419	},
420
421	flush(callback) {
422	process.nextTick(callback);	8✔
423	}
424	}))
425	.pipe(new DatasetStringifier())
426	.pipe(args.output);
427
428	await StreamUtils.waitFinish(args.output);	8✔
429	}
430	};

stanford-oval / genie-toolkit / 773

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