more elegant conversion

Author: sjanssen2

qiita_files/parse/tests/test_fastq.py

@@ -17,9 +17,9 @@
 class IterableData(object):
     def setUp(self):
         """ Initialize variables to be used by the tests as lists of strings"""
-        self.FASTQ_EXAMPLE = FASTQ_EXAMPLE.split('\n')
-        self.FASTQ_EXAMPLE_2 = FASTQ_EXAMPLE_2.split('\n')
-        self.FASTQ_EXAMPLE_3 = FASTQ_EXAMPLE_3.split('\n')
+        self.FASTQ_EXAMPLE = FASTQ_EXAMPLE.split(b'\n')
+        self.FASTQ_EXAMPLE_2 = FASTQ_EXAMPLE_2.split(b'\n')
+        self.FASTQ_EXAMPLE_3 = FASTQ_EXAMPLE_3.split(b'\n')
 
 
 class FileData(object):
@@ -30,7 +30,7 @@ def setUp(self):
                           ('FASTQ_EXAMPLE_2', FASTQ_EXAMPLE_2),
                           ('FASTQ_EXAMPLE_3', FASTQ_EXAMPLE_3)]:
             tmp_file = tempfile.NamedTemporaryFile('wb')
-            tmp_file.write(val.encode("utf-8"))
+            tmp_file.write(val)
             tmp_file.flush()
             tmp_file.seek(0)
             setattr(self, attr, tmp_file.name)
@@ -44,15 +44,15 @@ def tearDown(self):
 
 class ParseFastqTests(object):
     def test_parse(self):
-        for label, seq, qual in parse_fastq(list_str2bin(self.FASTQ_EXAMPLE),
+        for label, seq, qual in parse_fastq(self.FASTQ_EXAMPLE,
                                             phred_offset=64):
             self.assertTrue(label in DATA)
             self.assertEqual(seq, DATA[label]["seq"])
             self.assertTrue((qual == DATA[label]["qual"]).all())
 
         # Make sure that enforce_qual_range set to False allows qual scores
         # to fall outside the typically acceptable range of 0-62
-        for label, seq, qual in parse_fastq(list_str2bin(self.FASTQ_EXAMPLE_2),
+        for label, seq, qual in parse_fastq(self.FASTQ_EXAMPLE_2,
                                             phred_offset=33,
                                             enforce_qual_range=False):
             self.assertTrue(label in DATA_2)
@@ -63,18 +63,18 @@ def test_parse(self):
         # intended to be interpreted with an offset of 64, and using 33 will
         # make the qual score fall outside the acceptable range of 0-62.
         with self.assertRaises(ValueError):
-            list(parse_fastq(list_str2bin(self.FASTQ_EXAMPLE), phred_offset=33))
+            list(parse_fastq(self.FASTQ_EXAMPLE, phred_offset=33))
 
     def test_parse_error(self):
         with self.assertRaises(ValueError):
-            list(parse_fastq(list_str2bin(self.FASTQ_EXAMPLE_2), strict=True))
+            list(parse_fastq(self.FASTQ_EXAMPLE_2, strict=True))
 
         with self.assertRaises(ValueError):
-            list(parse_fastq(list_str2bin(self.FASTQ_EXAMPLE_3), phred_offset=64))
+            list(parse_fastq(self.FASTQ_EXAMPLE_3, phred_offset=64))
 
     def test_invalid_phred_offset(self):
         with self.assertRaises(ValueError):
-            list(parse_fastq(list_str2bin(self.FASTQ_EXAMPLE), phred_offset=42))
+            list(parse_fastq(self.FASTQ_EXAMPLE, phred_offset=42))
 
 
 class ParseFastqTestsInputIsIterable(IterableData, ParseFastqTests, TestCase):
@@ -154,11 +154,6 @@ class ParseFastqTestsInputIsFileNames(FileData, ParseFastqTests, TestCase):
                      64, 51, 63, 63, 65, 65, 65]))
 }
 
-def list_str2bin(inp):
-    if isinstance(inp, list):
-        return list(map(lambda x: x.encode("utf-8"), inp))
-    return inp
-
 
 FASTQ_EXAMPLE = r"""@GAPC_0015:6:1:1259:10413#0/1
 AACACCAAACTTCTCCACCACGTGAGCTACAAAAG
@@ -199,7 +194,7 @@ def list_str2bin(inp):
 @GAPC_0015:6:1:1317:3403#0/1
 TTGTTTCCACTTGGTTGATTTCACCCCTGAGTTTG
 +GAPC_0015:6:1:1317:3403#0/1
-\\\ZTYTSaLbb``\_UZ_bbcc`cc^[ac\a\Tc"""
+\\\ZTYTSaLbb``\_UZ_bbcc`cc^[ac\a\Tc""".encode("utf-8")
 
 
 FASTQ_EXAMPLE_2 = r"""@GAPC_0017:6:1:1259:10413#0/1
@@ -210,15 +205,15 @@ def list_str2bin(inp):
 TATGTATATATAACATATACATATATACATACATA
 +GAPC_0015:6:1:1283:11957#0/1
 ]KZ[PY]_[YY^```ac^\\`bT``c`\aT``bbb
-"""
+""".encode("utf-8")
 
 
 FASTQ_EXAMPLE_3 = r"""@GAPC_0017:6:1:1259:10413#0/1
 AACACCAAACTTCTCCACCACGTGAGCTACAAAAG
 +GAPC_0015:6:1:1259:10413#0/1
 ````Y^T]`]c^cabcacc`^Lb^ccYT\T\Y\WF
 @GAPC_0015:6:1:1283:11957#0/1
-"""
+""".encode("utf-8")
 
 
 if __name__ == "__main__":

qiita_files/parse/tests/test_iterator.py

@@ -15,6 +15,7 @@
 
 from qiita_files.parse.iterator import (SequenceIterator, FastaIterator,
                                         FastqIterator)
+from test_fastq import list_str2bin
 
 
 class SeqIterTests(TestCase):
@@ -276,61 +277,61 @@ def test_fastq_gen(self):
         self.assertEqual(obs3, exp3)
 
 
-fasta1 = rb""">1
+fasta1 = r""">1
 aattggcc
 >2
 aattaatt
-"""
+""".encode("utf-8")
 
-fasta2 = rb""">3
+fasta2 = r""">3
 atat
-"""
+""".encode("utf-8")
 
-fasta3 = rb""">4
+fasta3 = r""">4
 attatt
 >5
 ggccc
-"""
+""".encode("utf-8")
 
-qual1 = rb""">1
+qual1 = r""">1
 1 2 3 4 5 6 7 8
 >2
 8 7 6 5 4 3 2 1
-"""
+""".encode("utf-8")
 
-qual2 = rb""">3
+qual2 = r""">3
 1 2 3 4
-"""
+""".encode("utf-8")
 
-qual3 = rb""">4
+qual3 = r""">4
 1 2 3 4 5 6
 >5
 1 2 3 4 5
-"""
+""".encode("utf-8")
 
-qual_bad_val = rb""">3
+qual_bad_val = r""">3
 1 2
-"""
+""".encode("utf-8")
 
-qual_bad_id = rb""">asdasd
+qual_bad_id = r""">asdasd
 1 2 3 4
-"""
+""".encode("utf-8")
 
-fastq1 = rb"""@1
+fastq1 = r"""@1
 atat
 +
 ABCD
 @2
 atgc
 +
 BCDE
-"""
+""".encode("utf-8")
 
-fastq2 = rb"""@3
+fastq2 = r"""@3
 taa
 +
 EFG
-"""
+""".encode("utf-8")
 
 
 if __name__ == '__main__':