--- /dev/null
+"""General mechanisms to access applications in biopython.
+"""
+import os, sys
+import StringIO
+
+from Bio import File
+
+def generic_run(commandline):
+ """Run an application with the given commandline.
+
+ This expects a pre-built commandline that derives from
+ AbstractCommandline, and returns a ApplicationResult object
+ to get results from a program, along with handles of the
+ standard output and standard error.
+
+ WARNING - This will read in the full program output into memory!
+ This may be in issue when the program write a large amount of
+ data to standard output.
+ """
+ # print str(commandline)
+
+ #Try and use subprocess (available in python 2.4+)
+ try :
+ import subprocess, sys
+ #We don't need to supply any piped input, but we setup the
+ #standard input pipe anyway as a work around for a python
+ #bug if this is called from a Windows GUI program. For
+ #details, see http://bugs.python.org/issue1124861
+ child = subprocess.Popen(str(commandline),
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ shell=(sys.platform!="win32"))
+ child.stdin.close()
+ r = child.stdout
+ e = child.stderr
+
+ r_out = r.read()
+ e_out = e.read()
+ r.close()
+ e.close()
+
+ # capture error code
+ error_code = child.wait()
+
+ except ImportError :
+ #For python 2.3 can't use subprocess, using popen2 instead
+ #(deprecated in python 2.6)
+ import popen2
+ if sys.platform[:3]=='win':
+ # Windows does not have popen2.Popen3
+ r, w, e = popen2.popen3(str(commandline))
+
+ r_out = r.read()
+ e_out = e.read()
+ w.close()
+ r.close()
+ e.close()
+
+ # No way to get the error code; setting it to a dummy variable
+ error_code = 0
+
+ else:
+ child = popen2.Popen3(str(commandline), 1)
+ # get information and close the files, so if we call this function
+ # repeatedly we won't end up with too many open files
+
+ # here are the file descriptors
+ r = child.fromchild
+ w = child.tochild
+ e = child.childerr
+
+ r_out = r.read()
+ e_out = e.read()
+ w.close()
+ r.close()
+ e.close()
+
+ # capture error code
+ error_code = os.WEXITSTATUS(child.wait())
+
+ return ApplicationResult(commandline, error_code), \
+ File.UndoHandle(StringIO.StringIO(r_out)), \
+ File.UndoHandle(StringIO.StringIO(e_out))
+
+class ApplicationResult:
+ """Make results of a program available through a standard interface.
+
+ This tries to pick up output information available from the program
+ and make it available programmatically.
+ """
+ def __init__(self, application_cl, return_code):
+ """Intialize with the commandline from the program.
+ """
+ self._cl = application_cl
+
+ # provide the return code of the application
+ self.return_code = return_code
+
+ # get the application dependent results we can provide
+ # right now the only results we handle are output files
+ self._results = {}
+
+ for parameter in self._cl.parameters:
+ if "file" in parameter.param_types and \
+ "output" in parameter.param_types:
+ if parameter.is_set:
+ self._results[parameter.names[-1]] = parameter.value
+
+ def get_result(self, output_name):
+ """Retrieve result information for the given output.
+ """
+ return self._results[output_name]
+
+ def available_results(self):
+ """Retrieve a list of all available results.
+ """
+ result_names = self._results.keys()
+ result_names.sort()
+ return result_names
+
+class AbstractCommandline:
+ """Generic interface for running applications from biopython.
+
+ This class shouldn't be called directly; it should be subclassed to
+ provide an implementation for a specific application.
+ """
+ def __init__(self):
+ self.program_name = ""
+ self.parameters = []
+
+ def __str__(self):
+ """Make the commandline with the currently set options.
+ """
+ commandline = "%s " % self.program_name
+ for parameter in self.parameters:
+ if parameter.is_required and not(parameter.is_set):
+ raise ValueError("Parameter %s is not set." % parameter.names)
+ if parameter.is_set:
+ commandline += str(parameter)
+
+ return commandline
+
+ def set_parameter(self, name, value = None):
+ """Set a commandline option for a program.
+ """
+ set_option = 0
+ for parameter in self.parameters:
+ if name in parameter.names:
+ if value is not None:
+ self._check_value(value, name, parameter.checker_function)
+ parameter.value = value
+ parameter.is_set = 1
+ set_option = 1
+
+ if set_option == 0:
+ raise ValueError("Option name %s was not found." % name)
+
+ def _check_value(self, value, name, check_function):
+ """Check whether the given value is valid.
+
+ 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.
+ """
+ if check_function is not None:
+ is_good = check_function(value)
+ if is_good in [0, 1]: # if we are dealing with a good/bad check
+ if not(is_good):
+ raise ValueError(
+ "Invalid parameter value %r for parameter %s" %
+ (value, name))
+
+class _AbstractParameter:
+ """A class to hold information about a parameter for a commandline.
+
+ Do not use this directly, instead use one of the subclasses.
+
+ Attributes:
+
+ o names -- a list of string names by which the parameter can be
+ referenced (ie. ["-a", "--append", "append"]). The first name in
+ the list is considered to be the one that goes on the commandline,
+ for those parameters that print the option. The last name in the list
+ is assumed to be a "human readable" name describing the option in one
+ word.
+
+ o param_type -- a list of string describing the type of parameter,
+ which can help let programs know how to use it. Example descriptions
+ include 'input', 'output', 'file'
+
+ o checker_function -- a reference to a function that will determine
+ if a given value is valid for this parameter. This function can either
+ raise an error when given a bad value, or return a [0, 1] decision on
+ whether the value is correct.
+
+ o description -- a description of the option.
+
+ o is_required -- a flag to indicate if the parameter must be set for
+ the program to be run.
+
+ o is_set -- if the parameter has been set
+
+ o value -- the value of a parameter
+ """
+ def __init__(self, names = [], types = [], checker_function = None,
+ is_required = 0, description = ""):
+ self.names = names
+ self.param_types = types
+ self.checker_function = checker_function
+ self.description = description
+ self.is_required = is_required
+
+ self.is_set = 0
+ self.value = None
+
+class _Option(_AbstractParameter):
+ """Represent an option that can be set for a program.
+
+ This holds UNIXish options like --append=yes and -a yes
+ """
+ def __str__(self):
+ """Return the value of this option for the commandline.
+ """
+ # first deal with long options
+ if self.names[0].find("--") >= 0:
+ output = "%s" % self.names[0]
+ if self.value is not None:
+ output += "=%s " % self.value
+ else:
+ output += " "
+ # now short options
+ elif self.names[0].find("-") >= 0:
+ output = "%s " % self.names[0]
+ if self.value is not None:
+ output += "%s " % self.value
+ else:
+ raise ValueError("Unrecognized option type: %s" % self.names[0])
+
+ return output
+
+class _Argument(_AbstractParameter):
+ """Represent an argument on a commandline.
+ """
+ def __str__(self):
+ if self.value is not None:
+ return "%s " % self.value
+ else:
+ return " "
git://source.jalview.org / jabaws.git / blobdiff