[Python-Dev] PEP 3145 (With Contents)
Gregory P. Smith
greg at krypto.org
Sun Dec 9 05:17:52 CET 2012
I'm really not sure what this PEP is trying to get at given that it
contains no examples and sounds from the descriptions to be adding a
complicated api on top of something that already, IMNSHO, has too much it
Regardless, any user can use the stdout/err/in file objects with their own
code that handles them asynchronously (yes that can be painful but that is
what is required for _any_ socket or pipe I/O you don't want to block on).
It *sounds* to me like this entire PEP could be written and released as a
third party module on PyPI that offers a subprocess.Popen subclass adding
some more convenient non-blocking APIs. That's where I'd start if I were
interested in this as a future feature.
On Fri, Dec 7, 2012 at 5:10 PM, anatoly techtonik <techtonik at gmail.com>wrote:
> On Tue, Sep 15, 2009 at 9:24 PM, <exarkun at twistedmatrix.com> wrote:
>> On 04:25 pm, eric.pruitt at gmail.com wrote:
>>> I'm bumping this PEP again in hopes of getting some feedback.
> This is useful, indeed. ActiveState recipe for this has 10 votes, which is
> high for ActiveState (and such hardcore topic FWIW).
>> On Tue, Sep 8, 2009 at 23:52, Eric Pruitt <eric.pruitt at gmail.com> wrote:
>>>> PEP: 3145
>>>> Title: Asynchronous I/O For subprocess.Popen
>>>> Author: (James) Eric Pruitt, Charles R. McCreary, Josiah Carlson
>>>> Type: Standards Track
>>>> Content-Type: text/plain
>>>> Created: 04-Aug-2009
>>>> Python-Version: 3.2
>>>> In its present form, the subprocess.Popen implementation is prone to
>>>> dead-locking and blocking of the parent Python script while waiting
>>>> on data
>>>> from the child process.
>>>> A search for "python asynchronous subprocess" will turn up numerous
>>>> accounts of people wanting to execute a child process and
>>>> communicate with
>>>> it from time to time reading only the data that is available instead
>>>> blocking to wait for the program to produce data   . The
>>>> behavior of the subprocess module is that when a user sends or
>>>> data via the stdin, stderr and stdout file objects, dead locks are
>>>> and documented  . While communicate can be used to alleviate
>>>> some of
>>>> the buffering issues, it will still cause the parent process to
>>>> block while
>>>> attempting to read data when none is available to be read from the
>>>> There is a documented need for asynchronous, non-blocking
>>>> functionality in
>>>> subprocess.Popen    . Inclusion of the code would
>>>> improve the
>>>> utility of the Python standard library that can be used on Unix
>>>> based and
>>>> Windows builds of Python. Practically every I/O object in Python
>>>> has a
>>>> file-like wrapper of some sort. Sockets already act as such and for
>>>> strings there is StringIO. Popen can be made to act like a file by
>>>> using the methods attached the the subprocess.Popen.stderr, stdout
>>>> stdin file-like objects. But when using the read and write methods
>>>> those options, you do not have the benefit of asynchronous I/O. In
>>>> proposed solution the wrapper wraps the asynchronous methods to
>>>> mimic a
>>>> file object.
>>>> Reference Implementation:
>>>> I have been maintaining a Google Code repository that contains all
>>>> of my
>>>> changes including tests and documentation  as well as blog
>>>> the problems I have come across in the development process .
>>>> I have been working on implementing non-blocking asynchronous I/O in
>>>> subprocess.Popen module as well as a wrapper class for
>>>> that makes it so that an executed process can take the place of a
>>>> file by
>>>> duplicating all of the methods and attributes that file objects have.
>> "Non-blocking" and "asynchronous" are actually two different things. From
>> the rest of this PEP, I think only a non-blocking API is being introduced.
>> I haven't looked beyond the PEP, though, so I might be missing something.
> I suggest renaming http://www.python.org/dev/peps/pep-3145/ to
> 'Non-blocking I/O for subprocess' and continue. IMHO on this stage is where
> examples with deadlocks that occur with current subprocess
> implementation are badly needed.
> There are two base functions that have been added to the
>>>> class: Popen.send and Popen._recv, each with two separate
>>>> one for Windows and one for Unix based systems. The Windows
>>>> implementation uses ctypes to access the functions needed to control
>>>> in the kernel 32 DLL in an asynchronous manner. On Unix based
>>>> the Python interface for file control serves the same purpose. The
>>>> different implementations of Popen.send and Popen._recv have
>>>> arguments to make code that uses these functions work across multiple
>> Why does the method for non-blocking read from a pipe start with an "_"?
>> This is the convention (widely used) for a private API. The name also
>> doesn't suggest that this is the non-blocking version of reading.
>> Similarly, the name "send" doesn't suggest that this is the non-blocking
>> version of writing.
> The implementation is based on http://code.activestate.com/recipes/440554/which is more clearly illustrates integrated functionality.
> _recv() is a private base function, which is takes stdout or stderr as
> parameter. Corresponding user-level functions to read from stdout and
> stderr are .recv() and .recv_err()
> I thought about renaming API to .asyncread() and .asyncwrite(), but that
> may mean that you call method and then result asynchronously start to fill
> some buffer, which is not the case here.
> Then I thought about .check_read() and .check_write(), literally meaning
> 'check and read' or 'check and return' for non-blocking calls if there is
> nothing. But then again, poor naming convention of subprocess uses
> .check_output() for blocking read until command completes.
> Currently, subversion doesn't have .read and .write methods. It may be the
> best option:
> .write(what) to pipe more stuff into input buffer of child process.
> .read(from) where `from` is either subprocess.STDOUT or STDERR
> Both functions should be marked as non-blocking in docs and returning None
> if pipe is closed.
> When calling the Popen._recv function, it requires the pipe name be
>>>> passed as an argument so there exists the Popen.recv function that
>>>> selects stdout as the pipe for Popen._recv by default.
>>>> selects stderr as the pipe by default. "Popen.recv" and
>>>> are much easier to read and understand than "Popen._recv('stdout'
>>>> ..." and
>>>> "Popen._recv('stderr' ..." respectively.
>> What about reading from other file descriptors? subprocess.Popen allows
>> arbitrary file descriptors to be used. Is there any provision here for
>> reading and writing non-blocking from or to those?
> On Windows it is WriteFile/ReadFile and PeekNamedPipe. On Linux it is
> select. Of course a test is needed, but why it should not just work?
>> Since the Popen._recv function does not wait on data to be produced
>>>> before returning a value, it may return empty bytes. Popen.asyncread
>>>> handles this issue by returning all data read over a given time
>> Oh. Popen.asyncread? What's that? This is the first time the PEP
>> mentions it.
> I guess that's for blocking read with timeout.
> Among the most popular questions about Python it is the question number
>> The ProcessIOWrapper class uses the asyncread and asyncwrite
>>>> functions to
>>>> allow a process to act like a file so that there are no blocking
>>>> that can arise from using the stdout and stdin file objects produced
>>>> a subprocess.Popen call.
>> What's the ProcessIOWrapper class? And what's the asyncwrite function?
>> Again, this is the first time it's mentioned.
> Oh. That's a wrapper to access subprocess pipes with familiar file API. It
> is interesting:
>> So, to sum up, I think my main comment is that the PEP seems to be
>> missing a significant portion of the details of what it's actually
>> proposing. I suspect that this information is present in the
>> implementation, which I have not looked at, but it probably belongs in the
> Writing PEPs is definitely a job, and a hard one for developers. Too bad a
> good idea *and* implementation (tests needed) is put on hold, because there
> is nobody, who can help with that part.
> IMHO PEP needs to expand on user stories even if there is significant
> amount of cited sources, a practical summary and problem illustration by
> examples are missing.
> Python-Dev mailing list
> Python-Dev at python.org
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the Python-Dev