stanford-oval / genie-toolkit / 777

pending completion

Build # 777

Build Type

Pull #162

travis-ci-com

Committed by

web-flow

Commit Message

Merge b2c307208 into 980c444af

Pull Request Pull Request #162: Wip/multilanguage

Run Details

1333 of 4793 branches covered (27.81%)

Branch coverage included in aggregate %.

38 of 88 new or added lines in 11 files covered. (43.18%)

143 existing lines in 4 files now uncovered.

4067 of 9652 relevant lines covered (42.14%)

17108.45 hits per line

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

79.61

/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

    return requote_numbers && NUMBER_MATCH_REGEX.test(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) {
    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, ignoredProgramSpans) {
    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];
            if (!currentSpan || findSpanContaining(i, ignoredProgramSpans)) {
                newProgram.push(token);
                continue;
            }
            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, false);
            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 = [];

    let ignoredProgramSpans = [];

    // 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) {
            // skip requoting "small" numbers that do not exist in the sentence
            if (SMALL_NUMBER_REGEX.test(substring)) {
                ignoredProgramSpans.push({begin: begin_index, end:end_index, type:span_type});
                continue;
            } else {
                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, ignoredProgramSpans];
}


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

stanford-oval / genie-toolkit / 777

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