[IPython-dev] Qt/Curses interfaces future: results of the weekend mini-sprint (or having fun with 0mq)

Brian Granger ellisonbg at gmail.com
Tue Mar 23 18:05:23 EDT 2010


As Fernando has summarized our work very well. I too am very excited
about this development.  One thing that I don't think Fernando
mentioned is that stdout/stderr and Out (displayhook) are all handled
asynchronously AND broadcast to all users.

Thus, if you run the following

Py>>> for i in range(10):
  ...   print i
  ...   i**2
  ...   time.sleep(1)

You get the result asynchronously:

Out : 0
Out : None
[then wait 1 second]
Out : 1
Out : None
[then wait 1 second]
Out : 4
Out : None
[then wait 1 second]
Out : 9
Out : None
[then wait 1 second]
Out : 16
Out : None
[then wait 1 second]

etc.  If another user is connected to the kernel, They will also
receive these (along with the corresponding input) asynchronously.  In
a terminal based frontend these things are a little bit difficult to
demonstrate, but in a nice GUI frontend, we could imagine a nice a
interface to represent these things.



PS: Fernando, do you notice that time.sleep(1) (which returns None)
also triggers displayhook?  That is a bit odd.  Do we want to filter
out None from the displayhook?

On Tue, Mar 23, 2010 at 2:01 PM, Fernando Perez <fperez.net at gmail.com> wrote:
> Hi all,
> I realize that we have a significant task ahead in sorting some thorny
> issues out to get 0.11 ready for release, especially with respect to
> GUI handling.  But the big refactor of 0.11 starts to give us a clean
> codebase on which new/better interfaces using ipython can be built,
> and for that several people want to  contribute right away, so it's
> best that we build a path forward for those contributions, even if
> some of us still have to finish the 0.11 struggle.
> Wendell is looking into curses and Gerardo and Omar in Colombia are
> looking at Qt, and it would be fantastic to be able to get these
> developments moving forward soon.  So Brian and I got together over
> the weekend and  did a design/coding sprint that turned out to be
> surprisingly fun and productive.  This is the summary of those
> results.  I hope this thread can serve as a design brief we'll later
> formalize in the docs and which can be used to plan for a possible
> GSOC submission, for example (which the Qt guys have in mind).
> The basic issue we need to solve is the ability to have out-of-process
> interfaces that are efficient, simple to develop,  and that support
> fully asynchronous operation.  In today's ipython, you type code into
> a program that is the same tasked with executing the code,  so that if
> your code crashes, it takes the interface down with it.  So we need to
> have a two-process system where the user-facing client and the kernel
> that executes code live in separate processes (we'll retain a minimal
> in-process interface for embedding,  no worries, but the bulk of the
> real-world use should be in two processes).
> We want the user-facing client (be it readline-, curses- or qt-based)
> to remain responsive when the kernel is executing code, and to survive
> a full kernel crash.  So client/kernel need to communicate, and the
> communication should hopefully be possible *even when the kernel is
> busy*, at least to the extent that low-level messaging should continue
> to function even if the kernel is busy with Python  code.
> Up until now our engines use Twisted, and the above requirements can
> simply not be met with Twisted (not to mention Twisted's complexity
> and the concern we have with it not being ported soon to py3).  We
> recently stumbled on the 0mq messaging library:
> http://www.zeromq.org/
> and Brian was able to quickly build a set of Python bindings for it
> (see  link at the 0mq site, I'm writing this offline) using Cython.
> They are fast, we have  full  control over them, and since Cython is
> python-3 compliant, it means we can get a py3 version anytime we need.
> 0mq is a really amazing library: I'd only read about it recently and
> only used it for the first time this weekend (I started installing it
> at Brian's two days ago), and I was blown away by it.  It does all the
> messaging in C++ system threads that are 100% Python-threads safe, so
> the library is capable of queuing messages until the Python layer is
> available to handle them.  The api is dead-simple, it's blazingly
> fast, and we were able to get in two intense days a very real
> prototype that solves a number of problems that we were never able to
> make a dent into with Twisted.  Furthermore, with Twisted it was only
> really Brian and Min who ever wrote major amounts of code  for
> Ipython: twisted is really hard to grasp and has layers upon layers of
> abstraction,  making it a very difficult library to  pick up without a
> major commitment.  0mq is exactly the opposite: Brian explained the
> basic concepts to me in a few minutes (I haven't read a single doc
> yet!), we did some queuing tests interactively (by just making objects
> at an ipython prompt) and we then started writing a real prototype
> that now works.  We are very much considering abandoning twisted as we
> move forward and using 0mq for everything, including the distributed
> computing support (while keeping the user-facing apis unchanged).
> So what's in this example?  For now, you'll need to install 0mq and
> pyzmq from git; for 0mq, clone the repo at:
> git://github.com/sustrik/zeromq2.git
> then run
> ./autogen.sh
> ./configure --prefix=your_favorite_installation_prefix
> make
> make install
> This should give you a fully working 0mq.  Then for the python
> bindings, clone Brian's repo and get the kernel branch:
> git clone git://github.com/ellisonbg/pyzmq.git
> cd pyzmq
> git co -b kernel origin/kernel
> then
> cp setup.cfg.template setup.cfg
> and edit setup.cfg to indicate where you put your libraries.  This is
> basically the prefix above with /lib and /include appended.
> Then you can do the usual
> python setup.py install --prefix=your_favorite_installation_prefix
> The prototype we wrote lives in examples/kernel.  To play with it,
> open 3 terminals:
> - T1: run kernel.py, just leave it there.
> - T2 and T2: run frontend.py
> Both T2 and T3 are simple interactive prompts that run python code.
> You can quit them and restart them, type in both of them and they both
> manage the same namespace from the kernel in T1.  Each time you hit
> return, they synchronize with each other's input/output, so you can
> see what each client is sending to the kernel.  In a terminal this is
> done in-line and only when you hit return, but a curses/qt client with
> a real event loop can actually fire events when data arrives and
> display output from other clients as it is produced.
> You can 'background' inputs by putting ';' as the last character, and
> you can keep typing interactively while the kernel continues to
> process.  If you type something that's taking a long time, Ctrl-C will
> break out of  the wait but will leave the code running in the
> background (like Ctrl-Z in unix).
> This is NOT meant to be production code, it has no ipython
> dependencies at all,  no tab-completion yet,  etc.  It's meant to:
> - let us understand the basic design questions,
> - settle on the messaging api between clients and kernel,
> - establish what common api all clients can use: a base to be shared
> by readline/curses/qt clients, on top of which the frontend-specific
> code will go.
> So I'd encourage those of you who are interested in this problem to
> have a look and let us know how it goes.  For now the code lives in
> pyzmq because it makes for a great zmq example, but we're almost ready
> to start from it putting real ipython machinery.  For thinking about
> this design though, it's a lot easier to work with a tiny prototype
> that fits in 3 files than to deal with all of ipython's complexity.
> Cheers,
> f
> _______________________________________________
> IPython-dev mailing list
> IPython-dev at scipy.org
> http://mail.scipy.org/mailman/listinfo/ipython-dev

Brian E. Granger, Ph.D.
Assistant Professor of Physics
Cal Poly State University, San Luis Obispo
bgranger at calpoly.edu
ellisonbg at gmail.com

More information about the IPython-dev mailing list