Class AbstractCommandline
source code
object --+
|
AbstractCommandline
- Known Subclasses:
-
- Phylo.Applications._Phyml.PhymlCommandline
- , PopGen.GenePop.Controller._GenePopCommandline
- , Align.Applications._Clustalw.ClustalwCommandline
- , Align.Applications._Dialign.DialignCommandline
- , Align.Applications._Mafft.MafftCommandline
- , Align.Applications._Muscle.MuscleCommandline
- , Align.Applications._Prank.PrankCommandline
- , Align.Applications._Probcons.ProbconsCommandline
- , Align.Applications._TCoffee.TCoffeeCommandline
- , Blast.Applications._BlastCommandLine
- , Blast.Applications.FastacmdCommandline
- , Blast.Applications._NcbibaseblastCommandline
- , Motif.Applications._AlignAce.AlignAceCommandline
- , Motif.Applications._AlignAce.CompareAceCommandline
- , Sequencing.Applications._Novoalign.NovoalignCommandline
- , Emboss.Applications._EmbossMinimalCommandLine
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()
|
__init__(self,
cmd,
**kwargs)
Create a new instance of a command line wrapper object. |
source code
|
|
|
|
|
|
|
|
|
_get_parameter(self,
name)
Get a commandline option value. |
source code
|
|
|
_clear_parameter(self,
name)
Reset or clear a commandline option value. |
source code
|
|
|
set_parameter(self,
name,
value=None)
Set a commandline option for a program. |
source code
|
|
|
|
|
|
|
__call__(self,
stdin=None,
stdout=True,
stderr=True,
cwd=None,
env=None)
Executes the command, waits for it to finish, and returns output. |
source code
|
|
Inherited from object :
__delattr__ ,
__format__ ,
__getattribute__ ,
__hash__ ,
__new__ ,
__reduce__ ,
__reduce_ex__ ,
__sizeof__ ,
__subclasshook__
|
Inherited from object :
__class__
|
__init__(self,
cmd,
**kwargs)
(Constructor)
| source code
|
Create a new instance of a command line wrapper object.
- Overrides:
object.__init__
|
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.
|
__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__
|
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__
|
_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.
|
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__
|
__call__(self,
stdin=None,
stdout=True,
stderr=True,
cwd=None,
env=None)
(Call operator)
| source code
|
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:
%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.
|