Logo Search packages:      
Sourcecode: python-biopython version File versions  Download package


00001 """General mechanisms to access applications in biopython.
import os, sys
import StringIO
import popen2

from Bio import File

00009 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.
    # print str(commandline)
    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()

        # No way to get the error code; setting it to a dummy variable
        error_code = 0

        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()
        # capture error code
        error_code = os.WEXITSTATUS(child.wait())

    return ApplicationResult(commandline, error_code), \
           File.UndoHandle(StringIO.StringIO(r_out)), \

00054 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.
00060     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

00078     def get_result(self, output_name):
        """Retrieve result information for the given output.
        return self._results[output_name]

00083     def available_results(self):
        """Retrieve a list of all available results.
        result_names = self._results.keys()
        return result_names

00090 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 = []
00100     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

00112     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)

00127     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))
00143 class _AbstractParameter:
    """A class to hold information about a parameter for a commandline.

    Do not use this directly, instead use one of the subclasses.


    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

    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

00186 class _Option(_AbstractParameter):
    """Represent an option that can be set for a program.

    This holds UNIXish options like --append=yes and -a yes
00191     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
                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
            raise ValueError("Unrecognized option type: %s" % self.names[0])

        return output

00211 class _Argument(_AbstractParameter):
    """Represent an argument on a commandline.
    def __str__(self):
        if self.value is not None:
            return "%s " % self.value
            return " "

Generated by  Doxygen 1.6.0   Back to index