class StdCaptureFD(Capture):

def __init__(self, out=True, err=True, mixed=False, in_=True, patchsys=True): 

    if in_:

        self._oldin = (sys.stdin, os.dup(0))

        sys.stdin  = DontReadFromInput()

        fd = os.open(devnullpath, os.O_RDONLY)

        os.dup2(fd, 0)

        os.close(fd)

    if out: 

        self.out = py.io.FDCapture(1) 

        if patchsys: 

            self.out.setasfile('stdout')

    if err: 

        if mixed and out:

            tmpfile = self.out.tmpfile 

        else:

            tmpfile = None    

        self.err = py.io.FDCapture(2, tmpfile=tmpfile) 

        if patchsys: 

            self.err.setasfile('stderr')

def call(cls, func, *args, **kwargs): 

    """ return a (res, out, err) tuple where

            out and err represent the output/error output

            during function execution. 

            call the given function with args/kwargs

            and capture output/error during its execution. 

        """ 

    so = cls()

    try: 

        res = func(*args, **kwargs)

    finally: 

        out, err = so.reset()

    return res, out, err 

def done(self):

    """ return (outfile, errfile) and stop capturing. """

    outfile = errfile = emptyfile

    if hasattr(self, 'out'): 

        outfile = self.out.done() 

    if hasattr(self, 'err'): 

        errfile = self.err.done() 

    if hasattr(self, '_oldin'):

        oldsys, oldfd = self._oldin 

        os.dup2(oldfd, 0)

        os.close(oldfd)

        sys.stdin = oldsys 

    return outfile, errfile 

def reset(self): 

    """ reset sys.stdout and sys.stderr

            returns a tuple of file objects (out, err) for the captured

            data

        """

    outfile, errfile = self.done()

    return outfile.read(), errfile.read()