# license. Please see the LICENSE file that should have been included # as part of this package. """Unittests for Bio.Align.Applications interface for TCOFFEE.""" import sys import os import unittest from Bio import AlignIO, SeqIO, MissingExternalDependencyError from Bio.Align.Applications import TCoffeeCommandline #Try to avoid problems when the OS is in another language os.environ['LANG'] = 'C' t_coffee_exe = None if sys.platform == "win32": raise MissingExternalDependencyError( "Testing TCOFFEE on Windows not supported yet") else: from Bio._py3k import getoutput output = getoutput("t_coffee -version") if "not found" not in output \ and ("t_coffee" in output.lower() or "t-coffee" in output.lower()): t_coffee_exe = "t_coffee" if not t_coffee_exe: raise MissingExternalDependencyError( "Install TCOFFEE if you want to use the Bio.Align.Applications wrapper." ) class TCoffeeApplication(unittest.TestCase): def setUp(self):
#Tests simcoal related code. Note: this case requires simcoal #test_PopGen_SimCoal_nodepend tests code that does not require simcoal found = False for path in os.environ['PATH'].split(os.pathsep): try: for filename in os.listdir(path): if filename.startswith('simcoal2') \ or (filename.lower() == "simcoal2.exe") : found = True simcoal_dir = path except os.error: pass #Path doesn't exist - correct to pass if not found: raise MissingExternalDependencyError(\ "Install SIMCOAL2 if you want to use Bio.PopGen.SimCoal.") class AppTest(unittest.TestCase): """Tests simcoal execution via biopython. """ def tearDown(self): if not os.path.isdir(os.path.join('PopGen', 'simple')): #Unit test must have failed to invoke simcaol, #and this it never created the directory. return for file in os.listdir(os.path.join('PopGen', 'simple')): os.remove(os.sep.join(['PopGen', 'simple', file])) os.rmdir(os.path.join('PopGen', 'simple')) def test_simcoal(self):
exes_wanted = [ "water", "needle", "seqret", "transeq", "seqmatchall", "embossversion" ] exes = {} # Dictionary mapping from names to exe locations if "EMBOSS_ROOT" in os.environ: # Windows default installation path is C:\mEMBOSS which contains the exes. # EMBOSS also sets an environment variable which we will check for. path = os.environ["EMBOSS_ROOT"] if os.path.isdir(path): for name in exes_wanted: if os.path.isfile(os.path.join(path, name + ".exe")): exes[name] = os.path.join(path, name + ".exe") del name else: raise MissingExternalDependencyError( "$EMBOSS_ROOT=%r which does not exist!" % path) del path if sys.platform != "win32": from subprocess import getoutput for name in exes_wanted: # This will "just work" if installed on the path as normal on Unix output = getoutput("%s -help" % name) if "not found" not in output and "not recognized" not in output: exes[name] = name del output del name if len(exes) < len(exes_wanted): raise MissingExternalDependencyError( "Install EMBOSS if you want to use Bio.Emboss.")
hitlist_size=10, entrez_query=entrez_filter, expect=e_value, megablast="FALSE") else: handle = NCBIWWW.qblast(program, database, query, alignments=10, descriptions=10, hitlist_size=10, entrez_query=entrez_filter, expect=e_value) except HTTPError: # e.g. a proxy error raise MissingExternalDependencyError("internet connection failed") record = NCBIXML.read(handle) if record.query == "No definition line": # We used a sequence as the query assert len(query) == record.query_letters elif query.startswith(">"): # We used a FASTA record as the query assert query[1:].split("\n", 1)[0] == (record.query) else: # We used an identifier as the query assert query in record.query_id.split("|") # Check the recorded input parameters agree with those requested assert float(record.expect) == e_value assert record.application.lower() == program
fixers = refactor.get_fixers_from_package("lib2to3.fixes") fixers.remove("lib2to3.fixes.fix_print") # Already using print function rt = refactor.RefactoringTool(fixers) assert rt.refactor_docstring(">>> print(2+2)\n4\n", "example1") == \ ">>> print(2+2)\n4\n" assert rt.refactor_docstring('>>> print("Two plus two is", 2+2)\n' 'Two plus two is 4\n', "example2") == \ '>>> print("Two plus two is", 2+2)\nTwo plus two is 4\n' tutorial = os.path.join(os.path.dirname(sys.argv[0]), "../Doc/Tutorial.tex") if not os.path.isfile(tutorial) and sys.version_info[0] >= 3: tutorial = os.path.join(os.path.dirname(sys.argv[0]), "../../../Doc/Tutorial.tex") if not os.path.isfile(tutorial): from Bio import MissingExternalDependencyError raise MissingExternalDependencyError( "Could not find ../Doc/Tutorial.tex file") tutorial_base = os.path.abspath( os.path.join(os.path.dirname(sys.argv[0]), "../Doc/")) original_path = os.path.abspath(".") def _extract(handle): line = handle.readline() if line != "\\begin{verbatim}\n": raise ValueError( "Any '%doctest' or '%cont-doctest' line should be followed by '\\begin{verbatim}'" ) lines = [] while True: line = handle.readline()
# Copyright 2004-2008 by Michiel de Hoon. All rights reserved. # This code is part of the Biopython distribution and governed by its # license. Please see the LICENSE file that should have been included # as part of this package. # See the Biopython Tutorial for an explanation of the biological # background of these tests. try: import numpy except ImportError: from Bio import MissingExternalDependencyError raise MissingExternalDependencyError( "Install NumPy if you want to use Bio.LogisticRegression.") import unittest import sys from Bio import LogisticRegression xs = [[-53, -200.78], [117, -267.14], [57, -163.47], [16, -190.30], [11, -220.94], [85, -193.94], [16, -182.71], [15, -180.41], [-26, -181.73], [58, -259.87], [126, -414.53], [191, -249.57], [113, -265.28], [145, -312.99], [154, -213.83], [147, -380.85], [93, -291.13]] ys = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0] class TestLogisticRegression(unittest.TestCase): def test_calculate_model(self): model = LogisticRegression.train(xs, ys)
exes[name] = os.path.join(path, name + ".exe") del path, name if sys.platform != "win32": from subprocess import getoutput for name in exes_wanted: # This will "just work" if installed on the path as normal on Unix output = getoutput("%s -help" % name) if "not found" not in output and "not recognized" not in output: exes[name] = name del output del name if len(exes) < len(exes_wanted): raise MissingExternalDependencyError( "Install the Emboss package 'PhylipNew' if you want to use the " "Bio.Emboss.Applications wrappers for phylogenetic tools.") # ######################################################################### # A few top level functions that are called repeatedly in the test cases def write_AlignIO_dna(): """Convert opuntia.aln to a phylip file.""" assert 1 == AlignIO.convert("Clustalw/opuntia.aln", "clustal", "Phylip/opuntia.phy", "phylip") def write_AlignIO_protein(): """Convert hedgehog.aln to a phylip file.""" assert 1 == AlignIO.convert("Clustalw/hedgehog.aln", "clustal",
# license. Please see the LICENSE file that should have been included # as part of this package. """Unit tests for Bio.Phylo functions with external dependencies.""" import unittest from Bio._py3k import StringIO from Bio import Phylo # Check for any missing dependencies at the top level so we can skip from Bio import MissingExternalDependencyError try: import matplotlib except ImportError: raise MissingExternalDependencyError( "Install matplotlib if you want to use Bio.Phylo._utils.") # Don't use the Wx backend for matplotlib, use the simpler postscript # backend -- we're not going to display or save the plot anyway, so it # doesn't matter much, as long as it's not Wx. See: # http://lists.open-bio.org/pipermail/biopython-dev/2012-April/009559.html matplotlib.use("ps") try: from matplotlib import pyplot except ImportError: # Can fail here with font problems raise MissingExternalDependencyError( "Install matplotlib if you want to use Bio.Phylo._utils.") # Example PhyloXML file EX_DOLLO = "PhyloXML/o_tol_332_d_dollo.xml"
# Since "not found" may be in another language, try and be sure this is # really the bwa tool's output bwa_found = False if "not found" not in output and "bwa" in output \ and "alignment via Burrows-Wheeler transformation" in output: bwa_exe = "bwa" skip_aln_tests = False aln_output = getoutput("bwa aln") if "unrecognized" in aln_output: skip_aln_tests = True print("'bwa aln' is unrecognized, skipping aln/samse/sampe tests") if not bwa_exe: raise MissingExternalDependencyError("Install bwa and correctly set" " the file path to the program if" " you want to use it from Biopython") class BwaTestCase(unittest.TestCase): """Class for implementing BWA test cases""" def setUp(self): self.reference_file = "BWA/human_g1k_v37_truncated.fasta" self.reference_extensions = ['amb', 'ann', 'bwt', 'pac', 'sa'] self.infile1 = "BWA/HNSCC1_1_truncated.fastq" self.infile2 = "BWA/HNSCC1_2_truncated.fastq" self.saifile1 = "BWA/1.sai" self.saifile2 = "BWA/2.sai" self.samfile1 = "BWA/1.sam" self.samfile2 = "BWA/2.sam" self.samfile = "BWA/out.sam"
from Bio import MissingExternalDependencyError from Bio.PopGen.GenePop.Controller import GenePopController # Tests genepop related code. Note: this case requires genepop # test_PopGen_GenePop_nodepend tests code that does not require genepop found = False for path in os.environ['PATH'].split(os.pathsep): try: for filename in os.listdir(path): if filename.startswith('Genepop'): found = True except os.error: pass # Path doesn't exist - correct to pass if not found: raise MissingExternalDependencyError( "Install GenePop if you want to use Bio.PopGen.GenePop.") class AppTest(unittest.TestCase): """Tests genepop execution via biopython. """ def test_allele_genotype_frequencies(self): """Test genepop execution on basic allele and genotype frequencies. """ ctrl = GenePopController() pop_iter, locus_iter = ctrl.calc_allele_genotype_freqs("PopGen" + os.sep + "big.gen") # print("%s %s" % (pop, loci)) # for popc in pop_iter: # pop_name, loci_content = popc # print(pop_name)
def run_qblast( self, program, database, query, e_value, entrez_filter, additional_args, expected_hits, ): """Do qblast searches with given parameters and analyze results.""" try: if program == "blastn": # Check the megablast parameter is accepted handle = NCBIWWW.qblast(program, database, query, alignments=10, descriptions=10, hitlist_size=10, entrez_query=entrez_filter, expect=e_value, **additional_args) else: handle = NCBIWWW.qblast(program, database, query, alignments=10, descriptions=10, hitlist_size=10, entrez_query=entrez_filter, expect=e_value, **additional_args) except HTTPError: # e.g. a proxy error raise MissingExternalDependencyError( "internet connection failed") from None record = NCBIXML.read(handle) if record.query == "No definition line": # We used a sequence as the query self.assertEqual(len(query), record.query_letters) elif query.startswith(">"): # We used a FASTA record as the query expected = query[1:].split("\n", 1)[0] self.assertEqual(expected, record.query) elif (record.query_id.startswith("Query_") and len(query) == record.query_letters): # We used a sequence as the entry and it was given a placeholder name pass else: # We used an identifier as the query self.assertIn( query, record.query_id.split("|"), "Expected %r within query_id %r" % (query, record.query_id), ) # Check the recorded input parameters agree with those requested self.assertEqual(float(record.expect), e_value) self.assertEqual(record.application.lower(), program) self.assertTrue(len(record.alignments) <= 10) self.assertTrue(len(record.descriptions) <= 10) # Check the expected result(s) are found in the alignments if expected_hits is None: self.assertEqual(len(record.alignments), 0) # Expected no alignments! else: self.assertTrue( len(record.alignments) > 0) # Expected some alignments! found_result = False for expected_hit in expected_hits: for alignment in record.alignments: if expected_hit in alignment.hit_id.split("|"): found_result = True break self.assertTrue( found_result, "Missing all expected hits (%s), instead have: %s" % ( ", ".join(expected_hits), ", ".join(a.hit_id for a in record.alignments), ), ) # Check the expected result(s) are found in the descriptions if expected_hits is None: self.assertEqual(len(record.descriptions), 0) # Expected no descriptions! else: self.assertTrue( len(record.descriptions) > 0) # Expected some descriptions! found_result = False for expected_hit in expected_hits: for descr in record.descriptions: if expected_hit == descr.accession or expected_hit in descr.title.split( None, 1)[0].split("|"): found_result = True break assert found_result, "Missing all of %s in descriptions" % expected_hit self.assertTrue(found_result)
try : from numpy import asarray except ImportError : from Bio import MissingExternalDependencyError raise MissingExternalDependencyError(\ "Install NumPy if you want to use Bio.MarkovModel.") from Bio import MarkovModel def print_mm(markov_model): print "STATES: %s" % ' '.join(markov_model.states) print "ALPHABET: %s" % ' '.join(markov_model.alphabet) print "INITIAL:" for i in range(len(markov_model.p_initial)): print " %s: %.2f" % ( markov_model.states[i], markov_model.p_initial[i]) print "TRANSITION:" for i in range(len(markov_model.p_transition)): x = ["%.2f" % x for x in markov_model.p_transition[i]] print " %s: %s" % (markov_model.states[i], ' '.join(x)) print "EMISSION:" for i in range(len(markov_model.p_emission)): x = ["%.2f" % x for x in markov_model.p_emission[i]] print " %s: %s" % (markov_model.states[i], ' '.join(x)) print "TESTING train_visible" states = ["0", "1", "2", "3"] alphabet = ["A", "C", "G", "T"] training_data = [
# command, but this does cause them to quit cleanly. Otherwise they prompt # the user for input (causing a lock up). output = getoutput("clustalw2 --version") # Since "not found" may be in another language, try and be sure this is # really the clustalw tool's output if "not found" not in output and "not recognized" not in output: if "CLUSTAL" in output and "Multiple Sequence Alignments" in output: clustalw_exe = "clustalw2" if not clustalw_exe: output = getoutput("clustalw --version") if "not found" not in output and "not recognized" not in output: if "CLUSTAL" in output and "Multiple Sequence Alignments" in output: clustalw_exe = "clustalw" if not clustalw_exe: raise MissingExternalDependencyError( "Install clustalw or clustalw2 if you want to use it from Biopython.") class ClustalWTestCase(unittest.TestCase): """Class implementing common functions for ClustalW tests.""" def setUp(self): self.files_to_clean = set() def tearDown(self): for filename in self.files_to_clean: if os.path.isfile(filename): os.remove(filename) def standard_test_procedure(self, cline): """Shared test procedure used by all tests."""
user=DBUSER, passwd=DBPASSWD, host=DBHOST) server.close() del server except Exception, e: message = "Connection failed, check settings if you plan to use BioSQL: %s" % str( e) raise MissingExternalDependencyError(message) DBSCHEMA = "biosqldb-" + DBTYPE + ".sql" SQL_FILE = os.path.join(os.getcwd(), "BioSQL", DBSCHEMA) if not os.path.isfile(SQL_FILE): message = "Missing SQL schema file: %s" % SQL_FILE raise MissingExternalDependencyError(message) def _do_db_create(): """Do the actual work of database creation. Relevant for MySQL and PostgreSQL """ # first open a connection to create the database server = BioSeqDatabase.open_database(driver=DBDRIVER, user=DBUSER, passwd=DBPASSWD, host=DBHOST) if DBDRIVER == "pgdb": # The pgdb postgres driver does not support autocommit, so here we # commit the current transaction so that 'drop database' query will # be outside a transaction block
# # This file is part of the Biopython distribution and governed by your # choice of the "Biopython License Agreement" or the "BSD 3-Clause License". # Please see the LICENSE file that should have been included as part of this # package. """Unit tests for those parts of the Bio.PDB module using Bio.PDB.kdtrees.""" import unittest try: from numpy import array, dot, sqrt, argsort from numpy.random import random except ImportError: from Bio import MissingExternalDependencyError raise MissingExternalDependencyError( "Install NumPy if you want to use Bio.PDB.") from None try: from Bio.PDB import kdtrees except ImportError: from Bio import MissingExternalDependencyError raise MissingExternalDependencyError( "C module Bio.PDB.kdtrees not compiled") from None from Bio.PDB.NeighborSearch import NeighborSearch class NeighborTest(unittest.TestCase): def test_neighbor_search(self): """NeighborSearch: Find nearby randomly generated coordinates.
dice, a fair dice that has 1/6 probability of rolling any number and a loaded dice that has 1/2 probability to roll a 6, and 1/10 probability to roll any other number. The probability of switching from the fair to loaded dice is .05 and the probability of switching from loaded to fair is .1. """ from __future__ import print_function import os if os.name == 'java': from Bio import MissingExternalDependencyError # This is a slight miss-use of MissingExternalDependencyError, # but it will do in the short term to skip this unit test on Jython raise MissingExternalDependencyError( "This test can cause a fatal error " "on Jython with some versions of Java") # standard modules import random # biopython from Bio import Alphabet from Bio.Seq import MutableSeq from Bio.Seq import Seq # HMM stuff we are testing from Bio.HMM import MarkovModel from Bio.HMM import Trainer from Bio.HMM import Utilities
# print("Rejecting %r" % exe_name) del exe_name, name # To avoid the name clash with legacy BLAST, Debian introduced rpsblast+ alias wanted.remove("rpsblast+") if "rpsblast+" in exe_names: exe_names["rpsblast"] = exe_names["rpsblast+"] del exe_names["rpsblast+"] # We can cope with blast_formatter being missing, only added in BLAST 2.2.24+ # We can cope with deltablast being missing, only added in BLAST 2.2.26+ optional = ["blast_formatter", "deltablast"] if len(set(exe_names).difference(optional)) < len( set(wanted).difference(optional)): raise MissingExternalDependencyError( "Install the NCBI BLAST+ command line " "tools if you want to use the " "Bio.Blast.Applications wrapper.") class Pairwise(unittest.TestCase): def test_blastp(self): """Pairwise BLASTP search""" global exe_names cline = Applications.NcbiblastpCommandline( exe_names["blastp"], query="Fasta/rose.pro", subject="GenBank/NC_005816.faa", evalue=1) self.assertEqual( str(cline), _escape_filename(exe_names["blastp"]) +
os_path.extend(likely_dirs) for path in os.environ["PATH"].split(os.pathsep): exe_file = os.path.join(path, program) if is_exe(exe_file): return exe_file return None # Find the PAML binaries if sys.platform == "win32": binaries = ["codeml.exe", "baseml.exe", "yn00.exe"] else: binaries = ["codeml", "baseml", "yn00"] for binary in binaries: if which(binary) is None: raise MissingExternalDependencyError( "Install PAML if you want to use the Bio.Phylo.PAML wrapper.") class Common(unittest.TestCase): """Base class for PAML unit tests.""" del_files = [] def __del__(self): """Just in case tool creates some junk files, do a clean-up.""" del_files = self.del_files for filename in del_files: if os.path.exists(filename): os.remove(filename)
muscle_exe = os.path.join(folder, "muscle.exe") break if muscle_exe: break else: from Bio._py3k import getoutput output = getoutput("muscle -version") # Since "not found" may be in another language, try and be sure this is # really the MUSCLE tool's output if "not found" not in output and "MUSCLE" in output \ and "Edgar" in output: muscle_exe = "muscle" if not muscle_exe: raise MissingExternalDependencyError( "Install MUSCLE if you want to use the Bio.Align.Applications wrapper." ) ################################################################# class MuscleApplication(unittest.TestCase): def setUp(self): self.infile1 = "Fasta/f002" self.infile2 = "Fasta/fa01" self.infile3 = "Fasta/f001" self.outfile1 = "Fasta/temp align out1.fa" # with spaces! self.outfile2 = "Fasta/temp_align_out2.fa" self.outfile3 = "Fasta/temp_align_out3.fa" self.outfile4 = "Fasta/temp_align_out4.fa"
################################################################# # Try to avoid problems when the OS is in another language os.environ["LANG"] = "C" clustalo_exe = None try: output = getoutput("clustalo --help") if output.startswith("Clustal Omega"): clustalo_exe = "clustalo" except FileNotFoundError: pass if not clustalo_exe: raise MissingExternalDependencyError( "Install clustalo if you want to use Clustal Omega from Biopython.") class ClustalOmegaTestCase(unittest.TestCase): def setUp(self): self.files_to_clean = set() def tearDown(self): for filename in self.files_to_clean: if os.path.isfile(filename): os.remove(filename) def standard_test_procedure(self, cline): """Shared test procedure used by all tests.""" # Overwrite existing files. cline.force = True
from Bio.Phylo.Applications import RaxmlCommandline from Bio import MissingExternalDependencyError raxml_exe = None try: from subprocess import getoutput output = getoutput("raxmlHPC -v") if "not found" not in output and "not recognized" not in output: if "This is RAxML" in output: raxml_exe = "raxmlHPC" except FileNotFoundError: pass if not raxml_exe: raise MissingExternalDependencyError( "Install RAxML (binary raxmlHPC) if you want to test the Bio.Phylo.Applications wrapper." ) # Example Phylip file with 4 aligned protein sequences EX_PHYLIP = "Phylip/interlaced2.phy" class AppTests(unittest.TestCase): """Tests for application wrappers.""" def test_raxml(self): """Run RAxML using the wrapper.""" cmd = RaxmlCommandline(raxml_exe, sequences=EX_PHYLIP, model="PROTCATWAG", name="test") # The parsimony seed should be set automatically
from Bio import AlignIO from Bio import MissingExternalDependencyError from Bio import SeqIO from Bio.Align.Applications import MSAProbsCommandline from Bio.Application import ApplicationError from Bio._py3k import getoutput ################################################################# # Try to avoid problems when the OS is in another language os.environ['LANG'] = 'C' msaprobs_exe = None if sys.platform == "win32": # TODO raise MissingExternalDependencyError( "Testing this on Windows is not implemented yet") else: output = getoutput("msaprobs -version") if output.startswith("MSAPROBS version"): msaprobs_exe = "msaprobs" if not msaprobs_exe: raise MissingExternalDependencyError( "Install msaprobs if you want to use MSAProbs from Biopython.") class MSAProbsTestCase(unittest.TestCase): def setUp(self): self.files_to_clean = set() def tearDown(self):
# This code is part of the Biopython distribution and governed by its # license. Please see the LICENSE file that should have been included # as part of this package. try: import numpy except ImportError: from Bio import MissingExternalDependencyError raise MissingExternalDependencyError( "Install NumPy if you want to use Bio.KDTree.") try: from Bio.KDTree import _CKDTree except ImportError: from Bio import MissingExternalDependencyError raise MissingExternalDependencyError("C module in Bio.KDTree not compiled") from Bio.KDTree.KDTree import _neighbor_test, _test nr_points = 5000 dim = 3 bucket_size = 5 radius = 0.01 for i in range(0, 10): _neighbor_test(nr_points, dim, bucket_size, radius) _test(nr_points, dim, bucket_size, radius)
# as part of this package. """Unittests for Bio.Align.Applications interface for PROBCONS.""" import sys import os import unittest from Bio._py3k import StringIO from Bio import AlignIO, SeqIO, MissingExternalDependencyError from Bio.Align.Applications import ProbconsCommandline # Try to avoid problems when the OS is in another language os.environ['LANG'] = 'C' probcons_exe = None if sys.platform == "win32": raise MissingExternalDependencyError("PROBCONS not available on Windows") else: from Bio._py3k import getoutput output = getoutput("probcons") if "not found" not in output and "probcons" in output.lower(): probcons_exe = "probcons" if not probcons_exe: raise MissingExternalDependencyError( "Install PROBCONS if you want to use the Bio.Align.Applications wrapper.") class ProbconsApplication(unittest.TestCase): def setUp(self): self.infile1 = "Fasta/fa01"
"""Tests for online functionality of the KGML modules.""" # Builtins import os import unittest # Biopython from Bio.Graphics.ColorSpiral import ColorSpiral # Do we have ReportLab? Raise error if not present. from Bio import MissingExternalDependencyError try: from reportlab.pdfgen.canvas import Canvas from reportlab.lib.pagesizes import A4 except ImportError: raise MissingExternalDependencyError( "Install reportlab if you want to use Bio.Graphics.") from None # Do we have PIL? try: from PIL import Image except ImportError: raise MissingExternalDependencyError( "Install Pillow or its predecessor PIL (Python Imaging Library) " "if you want to use bitmaps from KGML.") from None # Biopython Bio.KEGG.KGML from Bio.KEGG.KGML.KGML_parser import read from Bio.Graphics.KGML_vis import KGMLCanvas # test_KGML_graphics module
as part of this package. """ import sys import os import unittest import subprocess from Bio import MissingExternalDependencyError from Bio.Align.Applications import MafftCommandline #Try to avoid problems when the OS is in another language os.environ['LANG'] = 'C' mafft_exe = None if sys.platform == "win32": raise MissingExternalDependencyError( "Testing with MAFFT not implemented on Windows yet") else: import commands output = commands.getoutput("mafft -help") if "not found" not in output and "MAFFT" in output: mafft_exe = "mafft" if not mafft_exe: raise MissingExternalDependencyError(\ "Install MAFFT if you want to use the Bio.Align.Applications wrapper.") def check_mafft_version(mafft_exe): child = subprocess.Popen("%s --help" % mafft_exe, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True,
# license. Please see the LICENSE file that should have been included # as part of this package. """Unittests for Bio.Align.Applications interface for DIALIGN2-2.""" import sys import os import unittest from Bio import MissingExternalDependencyError from Bio.Align.Applications import DialignCommandline # Try to avoid problems when the OS is in another language os.environ["LANG"] = "C" dialign_exe = None if sys.platform == "win32": raise MissingExternalDependencyError("DIALIGN2-2 not available on Windows") else: from subprocess import getoutput output = getoutput("dialign2-2") if "not found" not in output and "not recognized" not in output: if "dialign2-2" in output.lower(): dialign_exe = "dialign2-2" if "DIALIGN2_DIR" not in os.environ: raise MissingExternalDependencyError( "Environment variable DIALIGN2_DIR for DIALIGN2-2 missing." ) if not os.path.isdir(os.environ["DIALIGN2_DIR"]): raise MissingExternalDependencyError( "Environment variable DIALIGN2_DIR for DIALIGN2-2 is not a valid directory." )
fasttree_exe = os.path.join(prog_files, folder, filename) break if fasttree_exe: break else: import commands # Checking the -help argument output = commands.getoutput("fasttree -help") #Since "is not recognized" may be in another language, try and be sure this is #really the fasttree tool's output fasttree_found = False if "is not recognized" not in output and "protein_alignment" in output \ and "nucleotide_alignment" in output: fasttree_exe = "fasttree" if not fasttree_exe: raise MissingExternalDependencyError(\ "Install fasttree and correctly set the file path to the program if you want to use it from Biopython.") ################################################################# print "Checking error conditions" print "=========================" print "Empty file" input_file = "does_not_exist.fasta" output_file = "test.fasta" assert not os.path.isfile(input_file) cline = FastTreeCommandline(fasttree_exe, input=input_file, out=output_file) try: stdout, stderr = cline() assert False, "Should have failed, returned:\n%s\n%s" % (stdout, stderr) except ApplicationError, err:
# it right now, unless it starts to happen with real data! If anyone # can figure out the data that causes it so I can avoid it, that'd be much # appreciated. # standard library import os import random import unittest from Bio import MissingExternalDependencyError try: # Skip the test if reportlab is not installed import reportlab as r del r except ImportError: raise MissingExternalDependencyError( "Install reportlab if you want to use Bio.Graphics.") # the stuff we're testing from Bio.Graphics.Comparative import ComparativeScatterPlot class ComparativeTest(unittest.TestCase): """Do tests for modules involved with comparing data.""" def setUp(self): self.min_num_points = 1 self.max_num_points = 500 self.min_point_num = 0 self.max_point_num = 200 def _make_random_points(self, num_two_d_lists):
import os import unittest from Bio import SeqIO from Bio import AlignIO from Bio.Align.Applications import ClustalOmegaCommandline from Bio.Application import ApplicationError ################################################################# #Try to avoid problems when the OS is in another language os.environ['LANG'] = 'C' clustalo_exe = None if sys.platform == "win32": #TODO raise MissingExternalDependencyError( "Testing this on Windows not implemented yet") else: import commands output = commands.getoutput("clustalo --help") if output.startswith("Clustal Omega"): clustalo_exe = "clustalo" if not clustalo_exe: raise MissingExternalDependencyError(\ "Install clustalo if you want to use Clustal Omega from Biopython.") class ClustalOmegaTestCase(unittest.TestCase): def setUp(self): self.files_to_clean = set()