Renaming variable: Bio.Application.generic_run does not return stdin

Tests/test_Dialign_tool.py

@@ -56,14 +56,14 @@ def test_Dialign_simple(self):
         #Test using keyword arguments:
         cmdline = DialignCommandline(dialign_exe, input=self.infile1)
         self.assertEqual(str(cmdline), dialign_exe + " Fasta/f002")
-        stdin, stdout, stderr = Application.generic_run(cmdline)
+        result, stdout, stderr = Application.generic_run(cmdline)
         #If there is a problem, the output can be very helpful to see,
         #so check this before looking at the return code:
         self.assertEqual(stderr.read(), "")
         self.assertEqual(stdout.read(), "")
-        self.assertEqual(stdin.return_code, 0)
+        self.assertEqual(result.return_code, 0)
         self.assert_(os.path.exists(self.outfile1))
-        self.assertEqual(str(stdin._cl), str(cmdline))
+        self.assertEqual(str(result._cl), str(cmdline))
 
     def test_Dialign_simple_with_options(self):
         """Simple round-trip through app with infile and options
@@ -74,12 +74,12 @@ def test_Dialign_simple_with_options(self):
         cmdline.set_parameter("stars", 4)
         self.assertEqual(str(cmdline), dialign_exe + \
                          " -max_link -stars 4 Fasta/f002")
-        stdin, stdout, stderr = Application.generic_run(cmdline)
+        result, stdout, stderr = Application.generic_run(cmdline)
         self.assertEqual(stderr.read(), "")
         self.assertEqual(stdout.read(), "")
-        self.assertEqual(stdin.return_code, 0)
+        self.assertEqual(result.return_code, 0)
         self.assert_(os.path.exists(self.outfile1))
-        self.assertEqual(str(stdin._cl), str(cmdline))
+        self.assertEqual(str(result._cl), str(cmdline))
 
     def test_Dialign_simple_with_MSF_output(self):
         """Simple round-trip through app with infile, output MSF
@@ -89,13 +89,13 @@ def test_Dialign_simple_with_MSF_output(self):
         cmdline.input = self.infile1
         cmdline.msf = True
         self.assertEqual(str(cmdline), dialign_exe + " -msf Fasta/f002")
-        stdin, stdout, stderr = Application.generic_run(cmdline)
+        result, stdout, stderr = Application.generic_run(cmdline)
         self.assertEqual(stdout.read(), "")
         self.assertEqual(stderr.read(), "")
-        self.assertEqual(stdin.return_code, 0)
+        self.assertEqual(result.return_code, 0)
         self.assert_(os.path.exists(self.outfile1))
         self.assert_(os.path.exists(self.outfile2))
-        self.assertEqual(str(stdin._cl), str(cmdline))
+        self.assertEqual(str(result._cl), str(cmdline))
 
     def test_Dialign_complex_command_line(self):
         """Round-trip through app with complex command line."""
@@ -109,12 +109,12 @@ def test_Dialign_complex_command_line(self):
         cmdline.set_parameter("-cs", True)
         self.assertEqual(str(cmdline), dialign_exe + \
                          " -cs -mask -nt -ow -stars 9 -thr 4 Fasta/f002")
-        stdin, stdout, stderr = Application.generic_run(cmdline)
+        result, stdout, stderr = Application.generic_run(cmdline)
         self.assertEqual(stderr.read(), "")
-        self.assertEqual(stdin.return_code, 0)
+        self.assertEqual(result.return_code, 0)
         self.assert_(os.path.exists(self.outfile1))
         self.assert_(stdout.read().startswith(" e_len = 633"))
-        self.assertEqual(str(stdin._cl), str(cmdline))
+        self.assertEqual(str(result._cl), str(cmdline))
 
 if __name__ == "__main__":
     runner = unittest.TextTestRunner(verbosity = 2)

Tests/test_Mafft_tool.py

@@ -41,13 +41,13 @@ def test_Mafft_simple(self):
         #Use a keyword argument at init,
         cmdline = MafftCommandline(mafft_exe, input=self.infile1)
         self.assertEqual(str(eval(repr(cmdline))), str(cmdline))
-        stdin, stdout, stderr = Application.generic_run(cmdline)
+        result, stdout, stderr = Application.generic_run(cmdline)
         stderr_string = stderr.read()
-        self.assertEqual(stdin.return_code, 0)
+        self.assertEqual(result.return_code, 0)
         self.assert_(stdout.read().startswith(">gi|1348912|gb|G26680|G26680"))
         self.assert_("STEP     2 / 2 d" in stderr_string)
         self.assert_("$#=0" not in stderr_string)
-        self.assertEqual(str(stdin._cl), mafft_exe \
+        self.assertEqual(str(result._cl), mafft_exe \
                          + " Fasta/f002")
 
     def test_Mafft_with_options(self):
@@ -59,11 +59,11 @@ def test_Mafft_with_options(self):
         cmdline.set_parameter("maxiterate", 100)
         cmdline.set_parameter("--localpair", True)
         self.assertEqual(str(eval(repr(cmdline))), str(cmdline))
-        stdin, stdout, stderr = Application.generic_run(cmdline)
-        self.assertEqual(stdin.return_code, 0)
+        result, stdout, stderr = Application.generic_run(cmdline)
+        self.assertEqual(result.return_code, 0)
         self.assert_(stdout.read().startswith(">gi|1348912|gb|G26680|G26680"))
         self.assert_("$#=0" not in stderr.read())
-        self.assertEqual(str(stdin._cl), mafft_exe \
+        self.assertEqual(str(result._cl), mafft_exe \
                          + " --localpair --maxiterate 100 Fasta/f002")
 
     def test_Mafft_with_Clustalw_output(self):
@@ -73,11 +73,11 @@ def test_Mafft_with_Clustalw_output(self):
         cmdline.input = self.infile1
         cmdline.clustalout = True
         self.assertEqual(str(eval(repr(cmdline))), str(cmdline))
-        stdin, stdout, stderr = Application.generic_run(cmdline)
-        self.assertEqual(stdin.return_code, 0)
+        result, stdout, stderr = Application.generic_run(cmdline)
+        self.assertEqual(result.return_code, 0)
         self.assert_(stdout.read().startswith("CLUSTAL format alignment by MAFFT"))
         self.assert_("$#=0" not in stderr.read())
-        self.assertEqual(str(stdin._cl), mafft_exe \
+        self.assertEqual(str(result._cl), mafft_exe \
                          + " --clustalout Fasta/f002")
 
     def test_Mafft_with_complex_command_line(self):
@@ -97,11 +97,11 @@ def test_Mafft_with_complex_command_line(self):
         cmdline.set_parameter("--treeout", True)
         cmdline.set_parameter("nuc", True)
         self.assertEqual(str(eval(repr(cmdline))), str(cmdline))
-        stdin, stdout, stderr = Application.generic_run(cmdline)
-        self.assertEqual(stdin.return_code, 0)
+        result, stdout, stderr = Application.generic_run(cmdline)
+        self.assertEqual(result.return_code, 0)
         self.assert_(stdout.read().startswith(">gi|1348912|gb|G26680|G26680"))
         self.assert_("$#=0" not in stderr.read())
-        self.assertEqual(str(stdin._cl), mafft_exe \
+        self.assertEqual(str(result._cl), mafft_exe \
                          + " --localpair --weighti 4.2 --retree 5 " \
                          + "--maxiterate 200 --nofft --op 2.04 --ep 0.51" \
                          + " --lop 0.233 --lep 0.2 --reorder --treeout" \

Tests/test_Muscle_tool.py

@@ -80,11 +80,11 @@ def test_Muscle_simple(self):
         self.assertEqual(str(cmdline), muscle_exe \
                          + " -in Fasta/f002 -out Fasta/temp_align_out1.fa")
         self.assertEqual(str(eval(repr(cmdline))), str(cmdline))
-        stdin, stdout, stderr = generic_run(cmdline)
-        self.assertEqual(stdin.return_code, 0)
+        result, stdout, stderr = generic_run(cmdline)
+        self.assertEqual(result.return_code, 0)
         self.assertEqual(stdout.read(), "")
         self.assert_("ERROR" not in stderr.read())
-        self.assertEqual(str(stdin._cl), str(cmdline))
+        self.assertEqual(str(result._cl), str(cmdline))
 
     def test_Muscle_with_options(self):
         """Round-trip through app with a switch and valued option."""
@@ -99,11 +99,11 @@ def test_Muscle_with_options(self):
                          " -out Fasta/temp_align_out2.fa" + \
                          " -objscore sp -noanchors")
         self.assertEqual(str(eval(repr(cmdline))), str(cmdline))
-        stdin, stdout, stderr = generic_run(cmdline)
-        self.assertEqual(stdin.return_code, 0)
+        result, stdout, stderr = generic_run(cmdline)
+        self.assertEqual(result.return_code, 0)
         self.assertEqual(stdout.read(), "")
         self.assert_("ERROR" not in stderr.read())
-        self.assertEqual(str(stdin._cl), str(cmdline))
+        self.assertEqual(str(result._cl), str(cmdline))
 
     def test_Muscle_profile_simple(self):
         """Simple round-trip through app doing a profile alignment."""
@@ -116,11 +116,11 @@ def test_Muscle_profile_simple(self):
                          " -out Fasta/temp_align_out3.fa" + \
                          " -profile -in1 Fasta/fa01 -in2 Fasta/f001")
         self.assertEqual(str(eval(repr(cmdline))), str(cmdline))
-        stdin, stdout, stderr = generic_run(cmdline)
-        self.assertEqual(stdin.return_code, 0)
+        result, stdout, stderr = generic_run(cmdline)
+        self.assertEqual(result.return_code, 0)
         self.assertEqual(stdout.read(), "")
         self.assert_("ERROR" not in stderr.read())
-        self.assertEqual(str(stdin._cl), str(cmdline))
+        self.assertEqual(str(result._cl), str(cmdline))
 
     def test_Muscle_profile_with_options(self):
         """Profile alignment, and switch and valued options. """
@@ -137,11 +137,11 @@ def test_Muscle_profile_with_options(self):
         """
         #TODO - Why doesn't this work with MUSCLE 3.6 on the Mac?
         #It may be another bug fixed in MUSCLE 3.7 ...
-        stdin, stdout, stderr = generic_run(cmdline)
-        self.assertEqual(stdin.return_code, 0)
+        result, stdout, stderr = generic_run(cmdline)
+        self.assertEqual(result.return_code, 0)
         self.assertEqual(stdout.read(), "")
         self.assert_("ERROR" not in stderr.read())
-        self.assertEqual(str(stdin._cl), str(cmdline))
+        self.assertEqual(str(result._cl), str(cmdline))
         """
 
 class SimpleAlignTest(unittest.TestCase) :

Tests/test_Prank_tool.py

@@ -77,11 +77,11 @@ def test_Prank_simple(self):
         cmdline.set_parameter("d", self.infile1)
         self.assertEqual(str(cmdline), prank_exe + " -d=Fasta/fa01")
         self.assertEqual(str(eval(repr(cmdline))), str(cmdline))
-        stdin, stdout, stderr = Application.generic_run(cmdline)
-        self.assertEqual(stdin.return_code, 0)
+        result, stdout, stderr = Application.generic_run(cmdline)
+        self.assertEqual(result.return_code, 0)
         self.assert_("Total time" in stdout.read())
         self.assertEqual(stderr.read(), "")
-        self.assertEqual(str(stdin._cl), str(cmdline))
+        self.assertEqual(str(result._cl), str(cmdline))
 
     def test_Prank_simple_with_NEXUS_output(self):
         """Simple round-trip through app with infile, output in NEXUS
@@ -97,11 +97,11 @@ def test_Prank_simple_with_NEXUS_output(self):
         self.assertEqual(str(cmdline), prank_exe + \
                          " -d=Fasta/fa01 -f=17 -noxml -notree")
         self.assertEqual(str(eval(repr(cmdline))), str(cmdline))
-        stdin, stdout, stderr = Application.generic_run(cmdline)
-        self.assertEqual(stdin.return_code, 0)
+        result, stdout, stderr = Application.generic_run(cmdline)
+        self.assertEqual(result.return_code, 0)
         self.assert_("Total time" in stdout.read())
         self.assertEqual(stderr.read(), "")
-        self.assertEqual(str(stdin._cl), str(cmdline))
+        self.assertEqual(str(result._cl), str(cmdline))
         out_handle = open("output.2.nex", "r")
         align = AlignIO.read(out_handle, "nexus")
         out_handle.close()
@@ -130,11 +130,11 @@ def test_Prank_complex_command_line(self):
                          " -notree -dots -gaprate=0.321 -gapext=0.6 -kappa=3" + \
                          " -once -skipins -realbranches")
         self.assertEqual(str(eval(repr(cmdline))), str(cmdline))
-        stdin, stdout, stderr = Application.generic_run(cmdline)
-        self.assertEqual(stdin.return_code, 0)
+        result, stdout, stderr = Application.generic_run(cmdline)
+        self.assertEqual(result.return_code, 0)
         self.assert_("Total time" in stdout.read())
         self.assertEqual(stderr.read(), "")
-        self.assertEqual(str(stdin._cl), str(cmdline))
+        self.assertEqual(str(result._cl), str(cmdline))
 
 if __name__ == "__main__":
     runner = unittest.TextTestRunner(verbosity = 2)

Tests/test_Probcons_tool.py

@@ -41,9 +41,9 @@ def test_Probcons_alignment_fasta(self):
         cmdline = ProbconsCommandline(probcons_exe, input=self.infile1)
         self.assertEqual(str(cmdline), probcons_exe + " Fasta/fa01")
         self.assertEqual(str(eval(repr(cmdline))), str(cmdline))
-        stdin, stdout, stderr = Application.generic_run(cmdline)
-        self.assertEquals(stdin.return_code, 0)
-        self.assertEqual(str(cmdline), str(stdin._cl))
+        result, stdout, stderr = Application.generic_run(cmdline)
+        self.assertEquals(result.return_code, 0)
+        self.assertEqual(str(cmdline), str(result._cl))
         self.assert_(stderr.read().startswith("\nPROBCONS"))
         align = AlignIO.read(StringIO(stdout.read()), "fasta")
         records = list(SeqIO.parse(open(self.infile1),"fasta"))
@@ -60,9 +60,9 @@ def test_Probcons_alignment_clustalw(self):
         cmdline.clustalw = True
         self.assertEqual(str(cmdline), probcons_exe + " -clustalw Fasta/fa01")
         self.assertEqual(str(eval(repr(cmdline))), str(cmdline))
-        stdin, stdout, stderr = Application.generic_run(cmdline)
-        self.assertEquals(stdin.return_code, 0)
-        self.assertEqual(str(cmdline), str(stdin._cl))
+        result, stdout, stderr = Application.generic_run(cmdline)
+        self.assertEquals(result.return_code, 0)
+        self.assertEqual(str(cmdline), str(result._cl))
         self.assert_(stderr.read().strip().startswith("PROBCONS"))
         #self.assert_(stdout.read().strip().startswith("PROBCONS"))
         align = AlignIO.read(StringIO(stdout.read()), "clustal")
@@ -84,9 +84,9 @@ def test_Probcons_complex_commandline(self):
         self.assertEqual(str(cmdline), probcons_exe + 
                 " -c 4 -ir 222 -pre 1 -annot Fasta/probcons_annot.out "
                 "-a Fasta/fa01")
-        stdin, stdout, stderr = Application.generic_run(cmdline)
-        self.assertEqual(str(cmdline), str(stdin._cl))
-        self.assertEquals(stdin.return_code, 0)
+        result, stdout, stderr = Application.generic_run(cmdline)
+        self.assertEqual(str(cmdline), str(result._cl))
+        self.assertEquals(result.return_code, 0)
         self.assert_(stderr.read().startswith("\nPROBCONS"))
         self.assert_(stdout.read().startswith(">AK1H_ECOLI/1-378"))
 

Tests/test_TCoffee_tool.py

@@ -51,9 +51,9 @@ def test_TCoffee_1(self):
         """
         cmdline = TCoffeeCommandline(t_coffee_exe, infile=self.infile1)
         self.assertEqual(str(cmdline), t_coffee_exe + " -infile Fasta/fa01")
-        stdin, stdout, stderr = Application.generic_run(cmdline)
-        self.assertEquals(stdin.return_code, 0)
-        self.assertEquals(str(stdin._cl), t_coffee_exe + " -infile Fasta/fa01")
+        result, stdout, stderr = Application.generic_run(cmdline)
+        self.assertEquals(result.return_code, 0)
+        self.assertEquals(str(result._cl), t_coffee_exe + " -infile Fasta/fa01")
         self.assert_(stderr.read().strip().startswith("PROGRAM: T-COFFEE"))
         align = AlignIO.read(open(self.outfile1), "clustal")
         records = list(SeqIO.parse(open(self.infile1),"fasta"))
@@ -71,8 +71,8 @@ def test_TCoffee_2(self):
         cmdline.output = "pir_aln"
         self.assertEqual(str(cmdline), t_coffee_exe + " -output pir_aln "
                     "-infile Fasta/fa01 -outfile Fasta/tc_out.pir -quiet")
-        stdin, stdout, stderr = Application.generic_run(cmdline)
-        self.assertEquals(stdin.return_code, 0)
+        result, stdout, stderr = Application.generic_run(cmdline)
+        self.assertEquals(result.return_code, 0)
         self.assertEquals(stderr.read(), "")
         align = AlignIO.read(open(self.outfile3), "pir")
         records = list(SeqIO.parse(open(self.infile1),"fasta"))
@@ -94,8 +94,8 @@ def test_TCoffee_3(self):
         self.assertEqual(str(cmdline), t_coffee_exe + " -output clustalw_aln "
                          "-infile Fasta/fa01 -outfile Fasta/tc_out.phy "
                          "-outorder input -gapopen -2 -gapext -5")
-        stdin, stdout, stderr = Application.generic_run(cmdline)
-        self.assertEquals(stdin.return_code, 0)
+        result, stdout, stderr = Application.generic_run(cmdline)
+        self.assertEquals(result.return_code, 0)
         self.assert_(stderr.read().strip().startswith("PROGRAM: T-COFFEE"))
         align = AlignIO.read(open(self.outfile4), "clustal")
         records = list(SeqIO.parse(open(self.infile1),"fasta"))