Use modes in SequenceWriter (biopython#4850)

Also use a temporary file for GenBank output test

Bio/SeqIO/FastaIO.py

@@ -499,6 +499,8 @@ class FastaWriter(SequenceWriter):
     ``Bio.SeqIO.write()`` function instead using ``format="fasta"``.
     """
 
+    modes = "t"
+
     def __init__(self, target, wrap=60, record2title=None):
         """Create a Fasta writer (OBSOLETE).
 

Bio/SeqIO/InsdcIO.py

@@ -391,6 +391,8 @@ class _InsdcWriter(SequenceWriter):
         "transl_table",
     )
 
+    modes = "t"
+
     def _write_feature_qualifier(self, key, value=None, quote=None):
         if not _allowed_table_component_name_chars.issuperset(key):
             warnings.warn(

Bio/SeqIO/Interfaces.py

@@ -169,37 +169,45 @@ class SequenceWriter:
     the number of records.
     """
 
-    def __init__(self, target: _IOSource, mode: str = "w") -> None:
+    @property
+    @abstractmethod
+    def modes(self):
+        """File modes (binary or text) that the writer can handle.
+
+        This property must be "t" (for text mode only), "b" (for binary mode
+        only), "tb" (if both text and binary mode are accepted, but text mode
+        is preferred), or "bt" (if both text and binary mode are accepted, but
+        binary mode is preferred).
+        """
+        pass
+
+    def __init__(self, target: _IOSource) -> None:
         """Create the writer object."""
-        if mode == "w":
-            if isinstance(target, _PathLikeTypes):
-                # target is a path
-                handle = open(target, mode)
-            else:
+        if isinstance(target, _PathLikeTypes):
+            mode = self.modes[0]
+            stream = open(target, "w" + mode)
+        else:
+            stream = target
+            modes = "tb"
+            values = ("", b"")
+            for mode, value in zip(modes, values):
                 try:
-                    handle = target
-                    target.write("")
+                    stream.write(value)
                 except TypeError:
-                    # target was opened in binary mode
-                    raise StreamModeError("File must be opened in text mode.") from None
-        elif mode == "wb":
-            if isinstance(target, _PathLikeTypes):
-                # target is a path
-                handle = open(target, mode)
+                    continue
+                else:
+                    break
             else:
-                handle = target
-                try:
-                    target.write(b"")
-                except TypeError:
+                raise RuntimeError("Failed to read from input data") from None
+            if mode not in self.modes:
+                if mode == "t":
                     # target was opened in text mode
-                    raise StreamModeError(
-                        "File must be opened in binary mode."
-                    ) from None
-        else:
-            raise RuntimeError(f"Unknown mode '{mode}'")
-
-        self._target = target
-        self.handle = handle
+                    raise StreamModeError("File must be opened in binary mode.")
+                elif mode == "b":
+                    # target was opened in binary mode
+                    raise StreamModeError("File must be opened in text mode.")
+        self.target = target
+        self.handle = stream
 
     def clean(self, text: str) -> str:
         """Use this to avoid getting newlines in the output."""
@@ -269,7 +277,7 @@ def write_file(self, records, mincount=0, maxcount=None):
             count = self.write_records(records, maxcount)
             self.write_footer()
         finally:
-            if self.handle is not self._target:
+            if self.handle is not self.target:
                 self.handle.close()
         if count < mincount:
             if mincount == 1:  # Common case

Bio/SeqIO/NibIO.py

@@ -122,14 +122,16 @@ def __next__(self):
 class NibWriter(SequenceWriter):
     """Nib file writer."""
 
+    modes = "b"
+
     def __init__(self, target):
         """Initialize a Nib writer object.
 
         Arguments:
          - target - output stream opened in binary mode, or a path to a file
 
         """
-        super().__init__(target, mode="wb")
+        super().__init__(target)
 
     def write_header(self):
         """Write the file header."""

Bio/SeqIO/PhdIO.py

@@ -113,6 +113,8 @@ def __next__(self):
 class PhdWriter(SequenceWriter):
     """Class to write Phd format files."""
 
+    modes = "t"
+
     def __init__(self, handle: _IOSource) -> None:
         """Initialize the class."""
         super().__init__(handle)

Bio/SeqIO/PirIO.py

@@ -180,6 +180,8 @@ def __next__(self):
 class PirWriter(SequenceWriter):
     """Class to write PIR format files."""
 
+    modes = "t"
+
     def __init__(self, handle, wrap=60, record2title=None, code=None):
         """Create a PIR writer.
 

Bio/SeqIO/QualityIO.py

@@ -1588,6 +1588,8 @@ class FastqPhredWriter(SequenceWriter):
     >>> os.remove("Quality/temp.fastq")
     """
 
+    modes = "t"
+
     def write_record(self, record: SeqRecord) -> None:
         """Write a single FASTQ record to the file."""
         self._record_written = True
@@ -1667,6 +1669,8 @@ class QualPhredWriter(SequenceWriter):
     >>> os.remove("Quality/temp.qual")
     """
 
+    modes = "t"
+
     def __init__(
         self,
         handle: _TextIOSource,
@@ -1844,6 +1848,8 @@ class FastqSolexaWriter(SequenceWriter):
     >>> os.remove("Quality/temp.fastq")
     """
 
+    modes = "t"
+
     def write_record(self, record: SeqRecord) -> None:
         """Write a single FASTQ record to the file."""
         self._record_written = True
@@ -1926,6 +1932,8 @@ class FastqIlluminaWriter(SequenceWriter):
     warning is issued.
     """
 
+    modes = "t"
+
     def write_record(self, record: SeqRecord) -> None:
         """Write a single FASTQ record to the file."""
         self._record_written = True

Bio/SeqIO/SeqXmlIO.py

@@ -520,6 +520,8 @@ class SeqXmlWriter(SequenceWriter):
     "protein".
     """
 
+    modes = "b"
+
     def __init__(
         self, target, source=None, source_version=None, species=None, ncbiTaxId=None
     ):
@@ -536,7 +538,7 @@ def __init__(
          - ncbiTaxId - The NCBI taxonomy identifier of the species of origin.
 
         """
-        super().__init__(target, "wb")
+        super().__init__(target)
         handle = self.handle
         self.xml_generator = XMLGenerator(handle, "utf-8")
         self.xml_generator.startDocument()

Bio/SeqIO/SffIO.py

@@ -1121,6 +1121,8 @@ def __init__(self, source):
 class SffWriter(SequenceWriter):
     """SFF file writer."""
 
+    modes = "b"
+
     def __init__(self, target, index=True, xml=None):
         """Initialize an SFF writer object.
 
@@ -1132,7 +1134,7 @@ def __init__(self, target, index=True, xml=None):
            reading this data).
 
         """
-        super().__init__(target, "wb")
+        super().__init__(target)
         self._xml = xml
         if index:
             self._index = []

Bio/SeqIO/TabIO.py

@@ -110,6 +110,8 @@ class TabWriter(SequenceWriter):
     with ``format="tab"``.
     """
 
+    modes = "t"
+
     def write_record(self, record):
         """Write a single tab line to the file."""
         assert self._header_written

Bio/SeqIO/XdnaIO.py

@@ -224,14 +224,16 @@ def __next__(self):
 class XdnaWriter(SequenceWriter):
     """Write files in the Xdna format."""
 
+    modes = "b"
+
     def __init__(self, target):
         """Initialize an Xdna writer object.
 
         Arguments:
          - target - Output stream opened in binary mode, or a path to a file.
 
         """
-        super().__init__(target, mode="wb")
+        super().__init__(target)
 
     def write_file(self, records):
         """Write the specified record to a Xdna file.

Tests/test_GenBank.py

@@ -11,6 +11,7 @@
 
 import os
 import sys
+import tempfile
 import unittest
 import warnings
 from datetime import datetime
@@ -7811,15 +7812,17 @@ def test_qualifier_escaping_read(self):
     def test_qualifier_escaping_write(self):
         """Check qualifier escaping is preserved when writing."""
         # Write some properly escaped qualifiers and test
-        genbank_out = "GenBank/qualifier_escaping_write.gb"
-        record = SeqIO.read(genbank_out, "gb")
+        genbank_in = "GenBank/qualifier_escaping_write.gb"
+        record = SeqIO.read(genbank_in, "gb")
         f1 = record.features[0]
         f2 = record.features[1]
         f1.qualifiers["note"][0] = '"Should" now "be" escaped in "file"'
         f2.qualifiers["note"][0] = '"Should also be escaped in file"'
-        SeqIO.write(record, genbank_out, "gb")
-        # Read newly escaped qualifiers and test
-        record = SeqIO.read(genbank_out, "gb")
+        with tempfile.NamedTemporaryFile("w+") as genbank_out:
+            SeqIO.write(record, genbank_out, "gb")
+            genbank_out.seek(0)
+            # Read newly escaped qualifiers and test
+            record = SeqIO.read(genbank_out, "gb")
         f1 = record.features[0]
         f2 = record.features[1]
         self.assertEqual(