Beispiel #1
0
    def test_barcode_size_diff(self):
        barcodes5 = [
            'NATAN',
            'NNNCAGN',
        ]
        barcodes = demultiplex.prepare_barcodes(barcodes5, None)

        index = demultiplex.create_index(barcodes)
        expected = {
            1: {
                'A': {barcodes5[0]}
            },
            2: {
                'T': {barcodes5[0]}
            },
            3: {
                'A': {barcodes5[0]},
                'C': {barcodes5[1]},
            },
            4: {
                'A': {barcodes5[1]},
            },
            5: {
                'G': {barcodes5[1]},
            },
        }
        self.assertEqual(index, expected)
Beispiel #2
0
    def test_barcode_size_diff(self):
        # One mismatch, second barcode.
        barcodes = demultiplex.prepare_barcodes(self.barcodes5, None)
        entry1 = FastqEntry(
            '@header1',
            'TTAATT' + make_sequence(40),
            '+',
            make_quality_scores(44),
        )
        entry2 = FastqEntry(
            '@header2',
            'GGACGAGG' + make_sequence(40),
            '+',
            make_quality_scores(48),
        )
        fq_fname = self.create_fq_file([entry1, entry2])

        handle = demultiplex._extract(fq_fname,
                                      barcodes,
                                      mismatches=1,
                                      minimum_length=15)
        read1, wbrc, randomer1 = next(handle)
        self.assertEqual(wbrc, self.barcodes5[0])
        self.assertEqual(randomer1, 'TTT')
        self.assertEqual(read1.id, entry1.id)
        self.assertEqual(read1.seq, entry1.seq[6:])
        self.assertEqual(read1.plus, entry1.plus)
        self.assertEqual(read1.qual, entry1.qual[6:])
        read2, wbrc, randomer2 = next(handle)
        self.assertEqual(wbrc, self.barcodes5[2])
        self.assertEqual(randomer2, 'GGGG')
        self.assertEqual(read2.id, entry2.id)
        self.assertEqual(read2.seq, entry2.seq[8:])
        self.assertEqual(read2.plus, entry2.plus)
        self.assertEqual(read2.qual, entry2.qual[8:])
Beispiel #3
0
    def test_barcode3(self):
        barcodes5 = [
            'NATN',
            'NNCAN',
            'NNCAN',
        ]
        barcodes3 = [
            'NNTAG',
            'NNGT',
            '.',
        ]

        barcodes = demultiplex.prepare_barcodes(barcodes5, barcodes3)
        index = demultiplex.create_index(barcodes)
        self.assertEqual(
            index, {
                1: {
                    'A': {barcodes5[0]}
                },
                2: {
                    'T': {barcodes5[0]},
                    'C': {barcodes5[1]},
                },
                3: {
                    'A': {barcodes5[1]},
                },
            })

        index3 = demultiplex.create_index(barcodes['NATN']['barcodes3'])
        self.assertEqual(
            index3, {
                -3: {
                    'T': {barcodes3[0]},
                },
                -2: {
                    'A': {barcodes3[0]},
                },
                -1: {
                    'G': {barcodes3[0]},
                },
            })

        index3 = demultiplex.create_index(barcodes['NNCAN']['barcodes3'])
        self.assertEqual(index3, {
            -2: {
                'G': {barcodes3[1]},
            },
            -1: {
                'T': {barcodes3[1]},
            },
        })
Beispiel #4
0
    def test_extract_mismatch(self):
        # To many mismatches
        barcodes = demultiplex.prepare_barcodes(self.barcodes5, None)
        entry = FastqEntry(
            '@header1',
            'TTTTTT' + make_sequence(40),
            '+',
            make_quality_scores(46),
        )
        fq_fname = self.create_fq_file([entry])

        for read, wbrc, randomer in demultiplex._extract(fq_fname,
                                                         barcodes,
                                                         mismatches=0,
                                                         minimum_length=15):
            self.assertEqual(wbrc, 'nomatch')
            self.assertEqual(randomer, '')
            self.assertEqual(read.id, entry.id)
            self.assertEqual(read.seq, entry.seq)
            self.assertEqual(read.plus, entry.plus)
            self.assertEqual(read.qual, entry.qual)
Beispiel #5
0
    def test_extract_ok_2(self):
        # One mismatch, second barcode.
        barcodes = demultiplex.prepare_barcodes(self.barcodes5, None)
        entry = FastqEntry(
            '@header1',
            'TTAGTT' + make_sequence(40),
            '+',
            make_quality_scores(46),
        )
        fq_fname = self.create_fq_file([entry])

        for read, wbrc, randomer in demultiplex._extract(fq_fname,
                                                         barcodes,
                                                         mismatches=1,
                                                         minimum_length=15):
            self.assertEqual(wbrc, self.barcodes5[1])
            self.assertEqual(randomer, 'TTT')
            self.assertEqual(read.id, entry.id)
            self.assertEqual(read.seq, entry.seq[6:])
            self.assertEqual(read.plus, entry.plus)
            self.assertEqual(read.qual, entry.qual[6:])
Beispiel #6
0
    def test_barcode3(self):
        # One mismatch, second barcode.
        barcodes = demultiplex.prepare_barcodes(
            self.barcodes5 + [self.barcodes5[2]], self.barcodes3)
        barcodes = barcodes[self.barcodes5[2]]['barcodes3']
        entry1 = FastqEntry(
            '@header1',
            make_sequence(40) + 'TTGGG',
            '+',
            make_quality_scores(45),
        )
        entry2 = FastqEntry(
            '@header2',
            make_sequence(40) + 'TCAAA',
            '+',
            make_quality_scores(45),
        )
        fq_fname = self.create_fq_file([entry1, entry2])

        handle = demultiplex._extract(fq_fname,
                                      barcodes,
                                      mismatches=1,
                                      minimum_length=15)
        read1, wbrc, randomer1 = next(handle)
        self.assertEqual(wbrc, self.barcodes3[2])
        self.assertEqual(randomer1, 'TT')
        self.assertEqual(read1.id, entry1.id)
        self.assertEqual(read1.seq, entry1.seq[:-5])
        self.assertEqual(read1.plus, entry1.plus)
        self.assertEqual(read1.qual, entry1.qual[:-5])
        read2, wbrc, randomer2 = next(handle)
        self.assertEqual(wbrc, self.barcodes3[3])
        self.assertEqual(randomer2, 'TC')
        self.assertEqual(read2.id, entry2.id)
        self.assertEqual(read2.seq, entry2.seq[:-5])
        self.assertEqual(read2.plus, entry2.plus)
        self.assertEqual(read2.qual, entry2.qual[:-5])
Beispiel #7
0
    def test_create_index_simple(self):
        barcodes5 = [
            'NNAAAN',
            'NNACTN',
            'NNACGN',
        ]
        barcodes = demultiplex.prepare_barcodes(barcodes5, None)

        index = demultiplex.create_index(barcodes)
        expected = {
            2: {
                'A': {barcodes5[0], barcodes5[1], barcodes5[2]}
            },
            3: {
                'A': {barcodes5[0]},
                'C': {barcodes5[1], barcodes5[2]},
            },
            4: {
                'A': {barcodes5[0]},
                'T': {barcodes5[1]},
                'G': {barcodes5[2]},
            },
        }
        self.assertEqual(index, expected)