Class AbstractCommandline
source code
object --+
|
AbstractCommandline
- Known Subclasses:
-
- Emboss.Applications._EmbossMinimalCommandLine
- , Align.Applications._TCoffee.TCoffeeCommandline
- , Align.Applications._Probcons.ProbconsCommandline
- , Align.Applications._Muscle.MuscleCommandline
- , Align.Applications._Prank.PrankCommandline
- , Align.Applications._Clustalw.ClustalwCommandline
- , Align.Applications._Mafft.MafftCommandline
- , Align.Applications._Dialign.DialignCommandline
- , PopGen.GenePop.Controller._GenePopCommandline
- , Motif.Applications._AlignAce.AlignAceCommandline
- , Motif.Applications._AlignAce.CompareAceCommandline
- , Blast.Applications._BlastCommandLine
- , Blast.Applications.FastacmdCommandline
- , Blast.Applications._NcbiblastCommandline
- , Sequencing.Applications._Novoalign.NovoalignCommandline
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(capture=Ture)
|
__call__(self,
stdin=None,
stdout=True,
stderr=True)
Execute the command and waits for it to finish, returns output. |
source code
|
|
|
__init__(self,
cmd,
**kwargs)
Create a new instance of a command line wrapper object. |
source code
|
|
|
|
|
|
|
|
|
|
|
_clear_parameter(self,
name)
Reset or clear a commandline option value. |
source code
|
|
|
_get_parameter(self,
name)
Get a commandline option value. |
source code
|
|
|
|
|
set_parameter(self,
name,
value=None)
Set a commandline option for a program. |
source code
|
|
Inherited from object :
__delattr__ ,
__format__ ,
__getattribute__ ,
__hash__ ,
__new__ ,
__reduce__ ,
__reduce_ex__ ,
__sizeof__ ,
__subclasshook__
|
Inherited from object :
__class__
|
__call__(self,
stdin=None,
stdout=True,
stderr=True)
(Call operator)
| source code
|
Execute the command and waits for it to finish, 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.
Default example usage:
from Bio.Emboss.Applications import WaterCommandline
water_cmd = WaterCommandline(gapopen=10, gapextend=0.5, stdout=True,
asequence="a.fasta", bsequence="b.fasta")
print "About to run:
%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.
|
__init__(self,
cmd,
**kwargs)
(Constructor)
| source code
|
Create a new instance of a command line wrapper object.
- Overrides:
object.__init__
|
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)
- Overrides:
object.__repr__
|
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.
- Overrides:
object.__setattr__
|
__str__(self)
(Informal representation operator)
| source code
|
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'
- Overrides:
object.__str__
|
_check_value(self,
value,
name,
check_function)
| source code
|
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.
|
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.
|