Back to index

python-biopython  1.60
Public Member Functions | Public Attributes | Private Member Functions
Bio.Application.AbstractCommandline Class Reference
Inheritance diagram for Bio.Application.AbstractCommandline:
Inheritance graph
[legend]

List of all members.

Public Member Functions

def __init__
def __str__
def __repr__
def set_parameter
def __setattr__
def __call__

Public Attributes

 program_name

Private Member Functions

def _validate
def _get_parameter
def _clear_parameter
def _check_value

Detailed Description

Generic interface for constructing command line strings.

This class shouldn't be called directly; it should be subclassed to
provide an implementation for a specific application.

For a usage example we'll show one of the EMBOSS wrappers.  You can set
options when creating the wrapper object using keyword arguments - or
later using their corresponding properties:

>>> from Bio.Emboss.Applications import WaterCommandline
>>> cline = WaterCommandline(gapopen=10, gapextend=0.5)
>>> cline
WaterCommandline(cmd='water', gapopen=10, gapextend=0.5)

You can instead manipulate the parameters via their properties, e.g.

>>> cline.gapopen
10
>>> cline.gapopen = 20
>>> cline
WaterCommandline(cmd='water', gapopen=20, gapextend=0.5)

You can clear a parameter you have already added by 'deleting' the
corresponding property:

>>> del cline.gapopen
>>> cline.gapopen
>>> cline
WaterCommandline(cmd='water', gapextend=0.5)

Once you have set the parameters you need, turn the object into a string:

>>> str(cline)
Traceback (most recent call last):
...
ValueError: You must either set outfile (output filename), or enable filter or stdout (output to stdout).

In this case the wrapper knows certain arguments are required to construct
a valid command line for the tool.  For a complete example,

>>> from Bio.Emboss.Applications import WaterCommandline
>>> water_cmd = WaterCommandline(gapopen=10, gapextend=0.5)
>>> water_cmd.asequence = "asis:ACCCGGGCGCGGT"
>>> water_cmd.bsequence = "asis:ACCCGAGCGCGGT"
>>> water_cmd.outfile = "temp_water.txt"
>>> print water_cmd
water -outfile=temp_water.txt -asequence=asis:ACCCGGGCGCGGT -bsequence=asis:ACCCGAGCGCGGT -gapopen=10 -gapextend=0.5
>>> water_cmd
WaterCommandline(cmd='water', outfile='temp_water.txt', asequence='asis:ACCCGGGCGCGGT', bsequence='asis:ACCCGAGCGCGGT', gapopen=10, gapextend=0.5)

You would typically run the command line via a standard Python operating
system call using the subprocess module for full control. For the simple
case where you just want to run the command and get the output:

stdout, stderr = water_cmd()

Definition at line 90 of file __init__.py.


Constructor & Destructor Documentation

def Bio.Application.AbstractCommandline.__init__ (   self,
  cmd,
  kwargs 
)
Create a new instance of a command line wrapper object.

Reimplemented in Bio.Blast.Applications.NcbiblastformatterCommandline, Bio.Blast.Applications.NcbirpstblastnCommandline, Bio.Blast.Applications.NcbirpsblastCommandline, Bio.Emboss.Applications.SeqmatchallCommandline, Bio.Emboss.Applications.SeqretCommandline, Bio.Blast.Applications.NcbipsiblastCommandline, Bio.Emboss.Applications.IepCommandline, Bio.Emboss.Applications.DiffseqCommandline, Bio.Blast.Applications.NcbitblastxCommandline, Bio.Emboss.Applications.TranalignCommandline, Bio.Emboss.Applications.PalindromeCommandline, Bio.Emboss.Applications.EInvertedCommandline, Bio.Blast.Applications.NcbitblastnCommandline, Bio.Emboss.Applications.ETandemCommandline, Bio.Emboss.Applications.Est2GenomeCommandline, Bio.Blast.Applications.NcbiblastxCommandline, Bio.Emboss.Applications.FuzznucCommandline, Bio.Emboss.Applications.StretcherCommandline, Bio.Emboss.Applications.NeedleallCommandline, Bio.Blast.Applications.NcbiblastnCommandline, Bio.Emboss.Applications.NeedleCommandline, Bio.Emboss.Applications.WaterCommandline, Bio.Blast.Applications.NcbiblastpCommandline, Bio.Emboss.Applications.FConsenseCommandline, Bio.Blast.Applications._NcbiblastMain2SeqCommandline, Bio.Emboss.Applications.FProtDistCommandline, Bio.Emboss.Applications.FProtParsCommandline, Bio.Blast.Applications._Ncbiblast2SeqCommandline, Bio.Emboss.Applications.FDNAParsCommandline, Bio.Emboss.Applications.FSeqBootCommandline, Bio.Emboss.Applications.FNeighborCommandline, Bio.Emboss.Applications.FTreeDistCommandline, Bio.Blast.Applications._NcbiblastCommandline, Bio.Emboss.Applications.FDNADistCommandline, Bio.Emboss.Applications.PrimerSearchCommandline, Bio.Blast.Applications._NcbibaseblastCommandline, Bio.Blast.Applications.RpsBlastCommandline, Bio.Blast.Applications.BlastpgpCommandline, Bio.Blast.Applications.BlastallCommandline, Bio.Blast.Applications._BlastAllOrPgpCommandLine, Bio.Emboss.Applications.Primer3Commandline, Bio.Emboss.Applications._EmbossCommandLine, Bio.Align.Applications._Mafft.MafftCommandline, Bio.Motif.Applications._AlignAce.CompareAceCommandline, Bio.Blast.Applications._BlastCommandLine, Bio.Align.Applications._Probcons.ProbconsCommandline, Bio.Align.Applications._Prank.PrankCommandline, Bio.Align.Applications._TCoffee.TCoffeeCommandline, Bio.Align.Applications._ClustalOmega.ClustalOmegaCommandline, Bio.Phylo.Applications._Raxml.RaxmlCommandline, Bio.Blast.Applications.FastacmdCommandline, Bio.Align.Applications._Muscle.MuscleCommandline, Bio.Align.Applications._Clustalw.ClustalwCommandline, Bio.Align.Applications._Dialign.DialignCommandline, Bio.Sequencing.Applications._Novoalign.NovoalignCommandline, Bio.Emboss.Applications._EmbossMinimalCommandLine, Bio.Motif.Applications._AlignAce.AlignAceCommandline, and Bio.Phylo.Applications._Phyml.PhymlCommandline.

Definition at line 149 of file __init__.py.

00149 
00150     def __init__(self, cmd, **kwargs):
00151         """Create a new instance of a command line wrapper object."""
00152         # Init method - should be subclassed!
00153         # 
00154         # The subclass methods should look like this:
00155         # 
00156         # def __init__(self, cmd="muscle", **kwargs):
00157         #     self.parameters = [...]
00158         #     AbstractCommandline.__init__(self, cmd, **kwargs)
00159         # 
00160         # i.e. There should have an optional argument "cmd" to set the location
00161         # of the executable (with a sensible default which should work if the
00162         # command is on the path on Unix), and keyword arguments.  It should
00163         # then define a list of parameters, all objects derived from the base
00164         # class _AbstractParameter.
00165         # 
00166         # The keyword arguments should be any valid parameter name, and will
00167         # be used to set the associated parameter.
00168         self.program_name = cmd
00169         try:
00170             parameters = self.parameters
00171         except AttributeError:
00172             raise AttributeError("Subclass should have defined self.parameters")
00173         #Create properties for each parameter at run time
00174         aliases = set()
00175         for p in parameters:
00176             for name in p.names:
00177                 if name in aliases:
00178                     raise ValueError("Parameter alias %s multiply defined" \
00179                                      % name)
00180                 aliases.add(name)
00181             name = p.names[-1]
00182             if _re_prop_name.match(name) is None:
00183                 raise ValueError("Final parameter name %s cannot be used as "
00184                                  "an argument or property name in python"
00185                                  % repr(name))
00186             if name in _reserved_names:
00187                 raise ValueError("Final parameter name %s cannot be used as "
00188                                  "an argument or property name because it is "
00189                                  "a reserved word in python" % repr(name))
00190             if name in _local_reserved_names:
00191                 raise ValueError("Final parameter name %s cannot be used as "
00192                                  "an argument or property name due to the "
00193                                  "way the AbstractCommandline class works"
00194                                  % repr(name))
00195             #Beware of binding-versus-assignment confusion issues
00196             def getter(name):
00197                 return lambda x : x._get_parameter(name)
00198             def setter(name):
00199                 return lambda x, value : x.set_parameter(name, value)
00200             def deleter(name):
00201                 return lambda x : x._clear_parameter(name)
00202             doc = p.description
00203             if isinstance(p, _Switch):
00204                 doc += "\n\nThis property controls the addition of the %s " \
00205                        "switch, treat this property as a boolean." % p.names[0]
00206             else:
00207                 doc += "\n\nThis controls the addition of the %s parameter " \
00208                        "and its associated value.  Set this property to the " \
00209                        "argument value required." % p.names[0]
00210             prop = property(getter(name), setter(name), deleter(name), doc)
00211             setattr(self.__class__, name, prop) #magic!
00212         for key, value in kwargs.iteritems():
00213             self.set_parameter(key, value)
    

Here is the caller graph for this function:


Member Function Documentation

def Bio.Application.AbstractCommandline.__call__ (   self,
  stdin = None,
  stdout = True,
  stderr = True,
  cwd = None,
  env = None 
)
Executes the command, waits for it to finish, and returns output.

Runs the command line tool and waits for it to finish. If it returns
a non-zero error level, an exception is raised. Otherwise two strings
are returned containing stdout and stderr.

The optional stdin argument should be a string of data which will be
passed to the tool as standard input.

The optional stdout and stderr argument are treated as a booleans, and
control if the output should be captured (True, default), or ignored
by sending it to /dev/null to avoid wasting memory (False). In the
later case empty string(s) are returned.

The optional cwd argument is a string giving the working directory to
to run the command from. See Python's subprocess module documentation
for more details.

The optional env argument is a dictionary setting the environment
variables to be used in the new process. By default the current
process' environment variables are used. See Python's subprocess
module documentation for more details.

Default example usage:

from Bio.Emboss.Applications import WaterCommandline
water_cmd = WaterCommandline(gapopen=10, gapextend=0.5,
                     stdout=True, auto=True,
                     asequence="a.fasta", bsequence="b.fasta")
print "About to run:\n%s" % water_cmd
std_output, err_output = water_cmd()

This functionality is similar to subprocess.check_output() added in
Python 2.7. In general if you require more control over running the
command, use subprocess directly.

As of Biopython 1.56, when the program called returns a non-zero error
level, a custom ApplicationError exception is raised. This includes
any stdout and stderr strings captured as attributes of the exception
object, since they may be useful for diagnosing what went wrong.

Definition at line 368 of file __init__.py.

00368 
00369                  cwd=None, env=None):
00370         """Executes the command, waits for it to finish, and returns output.
00371         
00372         Runs the command line tool and waits for it to finish. If it returns
00373         a non-zero error level, an exception is raised. Otherwise two strings
00374         are returned containing stdout and stderr.
00375         
00376         The optional stdin argument should be a string of data which will be
00377         passed to the tool as standard input.
00378 
00379         The optional stdout and stderr argument are treated as a booleans, and
00380         control if the output should be captured (True, default), or ignored
00381         by sending it to /dev/null to avoid wasting memory (False). In the
00382         later case empty string(s) are returned.
00383 
00384         The optional cwd argument is a string giving the working directory to
00385         to run the command from. See Python's subprocess module documentation
00386         for more details.
00387 
00388         The optional env argument is a dictionary setting the environment
00389         variables to be used in the new process. By default the current
00390         process' environment variables are used. See Python's subprocess
00391         module documentation for more details.
00392 
00393         Default example usage:
00394 
00395         from Bio.Emboss.Applications import WaterCommandline
00396         water_cmd = WaterCommandline(gapopen=10, gapextend=0.5,
00397                                      stdout=True, auto=True,
00398                                      asequence="a.fasta", bsequence="b.fasta")
00399         print "About to run:\n%s" % water_cmd
00400         std_output, err_output = water_cmd()
00401 
00402         This functionality is similar to subprocess.check_output() added in
00403         Python 2.7. In general if you require more control over running the
00404         command, use subprocess directly.
00405         
00406         As of Biopython 1.56, when the program called returns a non-zero error
00407         level, a custom ApplicationError exception is raised. This includes
00408         any stdout and stderr strings captured as attributes of the exception
00409         object, since they may be useful for diagnosing what went wrong.
00410         """
00411         if stdout:
00412             stdout_arg = subprocess.PIPE
00413         else:
00414             stdout_arg = open(os.devnull)
00415         if stderr:
00416             stderr_arg = subprocess.PIPE
00417         else:
00418             stderr_arg = open(os.devnull)
00419         #We may not need to supply any piped input, but we setup the
00420         #standard input pipe anyway as a work around for a python
00421         #bug if this is called from a Windows GUI program.  For
00422         #details, see http://bugs.python.org/issue1124861
00423         #
00424         #Using universal newlines is important on Python 3, this
00425         #gives unicode handles rather than bytes handles.
00426         child_process = subprocess.Popen(str(self), stdin=subprocess.PIPE,
00427                                          stdout=stdout_arg, stderr=stderr_arg,
00428                                          universal_newlines=True,
00429                                          cwd=cwd, env=env,
00430                                          shell=(sys.platform!="win32"))
00431         #Use .communicate as can get deadlocks with .wait(), see Bug 2804
00432         stdout_str, stderr_str = child_process.communicate(stdin)
00433         if not stdout: assert not stdout_str
00434         if not stderr: assert not stderr_str
00435         return_code = child_process.returncode
00436         if return_code:
00437             raise ApplicationError(return_code, str(self),
00438                                    stdout_str, stderr_str)
00439         return stdout_str, stderr_str
00440 

Here is the call graph for this function:

Here is the caller graph for this function:

Return a representation of the command line object for debugging.

e.g.
>>> from Bio.Emboss.Applications import WaterCommandline
>>> cline = WaterCommandline(gapopen=10, gapextend=0.5)
>>> cline.asequence = "asis:ACCCGGGCGCGGT"
>>> cline.bsequence = "asis:ACCCGAGCGCGGT"
>>> cline.outfile = "temp_water.txt"
>>> print cline
water -outfile=temp_water.txt -asequence=asis:ACCCGGGCGCGGT -bsequence=asis:ACCCGAGCGCGGT -gapopen=10 -gapextend=0.5
>>> cline
WaterCommandline(cmd='water', outfile='temp_water.txt', asequence='asis:ACCCGGGCGCGGT', bsequence='asis:ACCCGAGCGCGGT', gapopen=10, gapextend=0.5)

Definition at line 251 of file __init__.py.

00251 
00252     def __repr__(self):
00253         """Return a representation of the command line object for debugging.
00254 
00255         e.g.
00256         >>> from Bio.Emboss.Applications import WaterCommandline
00257         >>> cline = WaterCommandline(gapopen=10, gapextend=0.5)
00258         >>> cline.asequence = "asis:ACCCGGGCGCGGT"
00259         >>> cline.bsequence = "asis:ACCCGAGCGCGGT"
00260         >>> cline.outfile = "temp_water.txt"
00261         >>> print cline
00262         water -outfile=temp_water.txt -asequence=asis:ACCCGGGCGCGGT -bsequence=asis:ACCCGAGCGCGGT -gapopen=10 -gapextend=0.5
00263         >>> cline
00264         WaterCommandline(cmd='water', outfile='temp_water.txt', asequence='asis:ACCCGGGCGCGGT', bsequence='asis:ACCCGAGCGCGGT', gapopen=10, gapextend=0.5)
00265         """
00266         answer = "%s(cmd=%s" % (self.__class__.__name__, repr(self.program_name))
00267         for parameter in self.parameters:
00268             if parameter.is_set:
00269                 if isinstance(parameter, _Switch):
00270                     answer += ", %s=True" % parameter.names[-1]
00271                 else:
00272                     answer += ", %s=%s" \
00273                               % (parameter.names[-1], repr(parameter.value))
00274         answer += ")"
00275         return answer

def Bio.Application.AbstractCommandline.__setattr__ (   self,
  name,
  value 
)
Set attribute name to value (PRIVATE).

This code implements a workaround for a user interface issue.
Without this __setattr__ attribute-based assignment of parameters
will silently accept invalid parameters, leading to known instances
of the user assuming that parameters for the application are set,
when they are not.

>>> from Bio.Emboss.Applications import WaterCommandline
>>> cline = WaterCommandline(gapopen=10, gapextend=0.5, stdout=True)
>>> cline.asequence = "a.fasta"
>>> cline.bsequence = "b.fasta"
>>> cline.csequence = "c.fasta"
Traceback (most recent call last):
...
ValueError: Option name csequence was not found.
>>> print cline
water -stdout -asequence=a.fasta -bsequence=b.fasta -gapopen=10 -gapextend=0.5

This workaround uses a whitelist of object attributes, and sets the
object attribute list as normal, for these.  Other attributes are
assumed to be parameters, and passed to the self.set_parameter method
for validation and assignment.

Definition at line 337 of file __init__.py.

00337 
00338     def __setattr__(self, name, value):
00339         """Set attribute name to value (PRIVATE).
00340 
00341         This code implements a workaround for a user interface issue.
00342         Without this __setattr__ attribute-based assignment of parameters
00343         will silently accept invalid parameters, leading to known instances
00344         of the user assuming that parameters for the application are set,
00345         when they are not.
00346         
00347         >>> from Bio.Emboss.Applications import WaterCommandline
00348         >>> cline = WaterCommandline(gapopen=10, gapextend=0.5, stdout=True)
00349         >>> cline.asequence = "a.fasta"
00350         >>> cline.bsequence = "b.fasta"
00351         >>> cline.csequence = "c.fasta"
00352         Traceback (most recent call last):
00353         ...
00354         ValueError: Option name csequence was not found.
00355         >>> print cline
00356         water -stdout -asequence=a.fasta -bsequence=b.fasta -gapopen=10 -gapextend=0.5
00357 
00358         This workaround uses a whitelist of object attributes, and sets the
00359         object attribute list as normal, for these.  Other attributes are
00360         assumed to be parameters, and passed to the self.set_parameter method
00361         for validation and assignment.
00362         """
00363         if name in ['parameters', 'program_name']: # Allowed attributes
00364             self.__dict__[name] = value
00365         else:
00366             self.set_parameter(name, value)  # treat as a parameter
    

Here is the call graph for this function:

Make the commandline string with the currently set options.

e.g.
>>> from Bio.Emboss.Applications import WaterCommandline
>>> cline = WaterCommandline(gapopen=10, gapextend=0.5)
>>> cline.asequence = "asis:ACCCGGGCGCGGT"
>>> cline.bsequence = "asis:ACCCGAGCGCGGT"
>>> cline.outfile = "temp_water.txt"
>>> print cline
water -outfile=temp_water.txt -asequence=asis:ACCCGGGCGCGGT -bsequence=asis:ACCCGAGCGCGGT -gapopen=10 -gapextend=0.5
>>> str(cline)
'water -outfile=temp_water.txt -asequence=asis:ACCCGGGCGCGGT -bsequence=asis:ACCCGAGCGCGGT -gapopen=10 -gapextend=0.5'

Definition at line 229 of file __init__.py.

00229 
00230     def __str__(self):
00231         """Make the commandline string with the currently set options.
00232 
00233         e.g.
00234         >>> from Bio.Emboss.Applications import WaterCommandline
00235         >>> cline = WaterCommandline(gapopen=10, gapextend=0.5)
00236         >>> cline.asequence = "asis:ACCCGGGCGCGGT"
00237         >>> cline.bsequence = "asis:ACCCGAGCGCGGT"
00238         >>> cline.outfile = "temp_water.txt"
00239         >>> print cline
00240         water -outfile=temp_water.txt -asequence=asis:ACCCGGGCGCGGT -bsequence=asis:ACCCGAGCGCGGT -gapopen=10 -gapextend=0.5
00241         >>> str(cline)
00242         'water -outfile=temp_water.txt -asequence=asis:ACCCGGGCGCGGT -bsequence=asis:ACCCGAGCGCGGT -gapopen=10 -gapextend=0.5'
00243         """
00244         self._validate()
00245         commandline = "%s " % self.program_name
00246         for parameter in self.parameters:
00247             if parameter.is_set:
00248                 #This will include a trailing space:
00249                 commandline += str(parameter)
00250         return commandline.strip() # remove trailing space

Here is the call graph for this function:

Here is the caller graph for this function:

def Bio.Application.AbstractCommandline._check_value (   self,
  value,
  name,
  check_function 
) [private]
Check whether the given value is valid.

No return value - it either works or raises a ValueError.

This uses the passed function 'check_function', which can either
return a [0, 1] (bad, good) value or raise an error. Either way
this function will raise an error if the value is not valid, or
finish silently otherwise.

Definition at line 320 of file __init__.py.

00320 
00321     def _check_value(self, value, name, check_function):
00322         """Check whether the given value is valid.
00323 
00324         No return value - it either works or raises a ValueError.
00325 
00326         This uses the passed function 'check_function', which can either
00327         return a [0, 1] (bad, good) value or raise an error. Either way
00328         this function will raise an error if the value is not valid, or
00329         finish silently otherwise.
00330         """
00331         if check_function is not None:
00332             is_good = check_function(value) #May raise an exception
00333             assert is_good in [0,1,True,False]
00334             if not is_good:
00335                 raise ValueError("Invalid parameter value %r for parameter %s" \
00336                                  % (value, name))

Here is the caller graph for this function:

def Bio.Application.AbstractCommandline._clear_parameter (   self,
  name 
) [private]
Reset or clear a commandline option value.

Definition at line 286 of file __init__.py.

00286 
00287     def _clear_parameter(self, name):
00288         """Reset or clear a commandline option value."""
00289         cleared_option = False
00290         for parameter in self.parameters:
00291             if name in parameter.names:
00292                 parameter.value = None
00293                 parameter.is_set = False
00294                 cleared_option = True
00295         if not cleared_option:
00296             raise ValueError("Option name %s was not found." % name)
        
def Bio.Application.AbstractCommandline._get_parameter (   self,
  name 
) [private]
Get a commandline option value.

Definition at line 276 of file __init__.py.

00276 
00277     def _get_parameter(self, name):
00278         """Get a commandline option value."""
00279         for parameter in self.parameters:
00280             if name in parameter.names:
00281                 if isinstance(parameter, _Switch):
00282                     return parameter.is_set
00283                 else:
00284                     return parameter.value
00285         raise ValueError("Option name %s was not found." % name)

Here is the caller graph for this function:

Make sure the required parameters have been set (PRIVATE).

No return value - it either works or raises a ValueError.

This is a separate method (called from __str__) so that subclasses may
override it.

Reimplemented in Bio.Blast.Applications.NcbiblastformatterCommandline, Bio.Blast.Applications.NcbirpsblastCommandline, Bio.Blast.Applications.NcbipsiblastCommandline, Bio.Emboss.Applications.SeqretCommandline, Bio.Blast.Applications.NcbiblastnCommandline, Bio.Blast.Applications._NcbiblastMain2SeqCommandline, Bio.Blast.Applications._Ncbiblast2SeqCommandline, Bio.Blast.Applications._NcbiblastCommandline, Bio.Blast.Applications._BlastCommandLine, and Bio.Emboss.Applications._EmbossCommandLine.

Definition at line 214 of file __init__.py.

00214 
00215     def _validate(self):
00216         """Make sure the required parameters have been set (PRIVATE).
00217 
00218         No return value - it either works or raises a ValueError.
00219 
00220         This is a separate method (called from __str__) so that subclasses may
00221         override it.
00222         """
00223         for p in self.parameters:
00224             #Check for missing required parameters:
00225             if p.is_required and not(p.is_set):
00226                 raise ValueError("Parameter %s is not set." \
00227                                  % p.names[-1])
00228             #Also repeat the parameter validation here, just in case?

Here is the caller graph for this function:

def Bio.Application.AbstractCommandline.set_parameter (   self,
  name,
  value = None 
)
Set a commandline option for a program.

Definition at line 297 of file __init__.py.

00297 
00298     def set_parameter(self, name, value = None):
00299         """Set a commandline option for a program.
00300         """
00301         set_option = False
00302         for parameter in self.parameters:
00303             if name in parameter.names:
00304                 if isinstance(parameter, _Switch):
00305                     if value is None:
00306                         import warnings
00307                         warnings.warn("For a switch type argument like %s, "
00308                                       "we expect a boolean.  None is treated "
00309                                       "as FALSE!" % parameter.names[-1])
00310                     parameter.is_set = bool(value)
00311                     set_option = True
00312                 else:
00313                     if value is not None:
00314                         self._check_value(value, name, parameter.checker_function)
00315                         parameter.value = value
00316                     parameter.is_set = True
00317                     set_option = True
00318         if not set_option:
00319             raise ValueError("Option name %s was not found." % name)

Here is the call graph for this function:

Here is the caller graph for this function:


Member Data Documentation

Reimplemented in Bio.Align.Applications._Dialign.DialignCommandline.

Definition at line 167 of file __init__.py.


The documentation for this class was generated from the following file: