matplotlib-users Mailing List for matplotlib

>>>>> "Thomas" == Thomas Barket <tho...@ya...> writes:

    Thomas> John, Tks again for your help.  I thought that you were
    Thomas> running that script in plain old ipython.  I didn't
    Thomas> realize ipython-gtk was different from ipython.  After
    Thomas> reading your last message, I downloaded and began using
    Thomas> ipython 0.6.2 for python 2.3.  I thought ipython-gtk was
    Thomas> some linux variant of ipython (im on windows xp).  I
    Thomas> appreciate now that it is a different animal entirely.  My
    Thomas> mix-up on that.  Sorry for the confusion.

    Thomas> There is no mention of ipython-gtk or pyint-gtk on the
    Thomas> ipython.scipy.org web site.  Is there any documentation
    Thomas> yet that I can see, perhaps tucked away in a cvs branch
    Thomas> somewhere?

    Thomas> I have enough to get going now.

No you don't!  ipython 0.6.2 *will not work* with interactive
matplotlib/gtk.  

ipython-gtk is not mentioned on the ipython site because it is not in
the main release yet.  It is only in CVS (and requires matplotlib CVS
as well) and is not yet fully functional.  That is why I recommended
to use pyint-gtk.py and included it in my email, which was written by
Fernando as an ipython-gtk prototyping script.  pyint-gtk.py will work
with the current matplotlib/gtk and requires no extra packages.

Keep your eyes on this list in the next few weeks for a fully
functional, integrated, ipython-gtk.

Sorry for the complexity - you're just coming into an area that is
being actively developed and changing almost daily.

JDH

John,

Tks again for your help.   I thought that you were running that script in
plain old ipython.  I didn't realize ipython-gtk was different from ipython.
After reading your last message, I downloaded and began using ipython 0.6.2
for python 2.3.  I thought ipython-gtk was some linux variant of ipython (im
on windows xp).  I appreciate now that it is a different animal entirely.
My mix-up on that.  Sorry for the confusion.

There is no mention of ipython-gtk or pyint-gtk on the ipython.scipy.org web
site.  Is there any documentation yet that I can see, perhaps tucked away in
a cvs branch somewhere?

I have enough to get going now.

Tks again,

Tom


-----Original Message-----
From: John Hunter [mailto:jdh...@ac...] 
Sent: Friday, August 20, 2004 8:36 AM
To: Thomas Barket
Cc: mat...@li...
Subject: Re: [Matplotlib-users] Requesting advice on multi-threaded
matplotlib session + grids displaying data

>>>>> "Thomas" == Thomas Barket <tho...@ya...> writes:

    Thomas> John, That makes sense.  Tks vm.

    Thomas> I am still confused on what approach needs to be taken to
    Thomas> get the data grids to be *interactive* from the python
    Thomas> command prompt.  It seems to me that such interactivity
    Thomas> requires threading (ie, creating any new data grid gui
    Thomas> window in its own thread).  Is that correct, or is there
    Thomas> some other way to do it?

OK, I appreciate that it's confusing.  It's not an easy subject.  I suggest
you give http://matplotlib.sourceforge.net/interactive.html
and http://matplotlib.sourceforge.net/faq.html#SHOW another reading because
your comments below indicate you haven't fully digested that material.  I
take full responsibility for this, however, because I wrote the docs!

I'll elaborate somewhat.

First a reminder which I think you already understand: matplotlib has an
interactive mode and a non-interactive mode.  You want to use the
interactive mode, set 'interactive : True' in your rc file.  In interactive
mode do not call show, ever.  OK.

Your real problem is how to start the mainloop vis-a-vis threading.
The answer is (for gtk/gtkagg), use a custom python shell for pygtk.
The idea here is that the custom shell starts the mainloop for you.
When you import matplotlib with interactive on from one of these shells, the
mainloop is already started in a separate thread, and you can issue plot
commands and get immediate responses without losing control of the prompt.
Of course, you can launch other gtk windows and widgets too.

There are a variety of python shells out there for pygtk, but I strongly
recommend you start with Fernando Perez's pyint-gtk.py.  
If you notice in my last post to you, I wrote

  > Here is an example using Fernando's ipython-gtk
                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  > hunter:~/python/examples/pygtk> python ~/tmp/ip/ipython-gtk.py
  > Python 2.3.2 (#1, Oct 13 2003, 11:33:15)
  > [GCC 3.3.1] on linux2
  > Type "copyright", "credits" or "license" for more information.
  > (MatplotlibShell)

  > 1 >>> from matplotlib.numerix import rand
  > 2 >>> from array_to_grid import view_array
  > 3 >>> view_array( rand(20,10))
  > Out[3]: <ArrayView object (GtkWindow) at 0x4136db94>

I would have emphasized that but I wrongly assumed you knew you needed a
threaded GTK shell.  I guess I've been doing this too long :-)

pyint-gtk.py is just a temporary proof-of-concept to lay the groundwork for
ipython-gtk, which will be a full featured ipython shell with gtk/matplotlib
support.  If you haven't checked out ipython, you should, as it's *very
nice* for interactive work.
Nonetheless, the current release of ipython doesn't support gtk/matplotlib,
and pyint-gtk.py is as good as the standard shell.
Plus we need testers, because the guts of this shell will become the guts of
ipython-gtk.

If you start it with 

  > python pyint-gtk.py -mplot 

it will not only start the gtk mainloop but will import all of matplotlib,
so if the first command you type is

  >>> plot([1,2,3[])

a plot will pop up.  And you can import and use the view_array code I posted
before as well.

I'll include the src for pyint-gtk.py here, as it is short

Hope this helps,
JDH

#!/usr/bin/env python
"""Multithreaded interactive interpreter with GTK and Matplotlib support.

Usage:

  pyint-gtk.py -> starts shell with gtk thread running separately

  pyint-gtk.py -mplot [filename] -> initializes matplotlib, optionally
running
  the named file.  The shell starts after the file is executed.

Threading code inspired by:
http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by Brian
McErlean and John Finlay.

Matplotlib support taken from interactive.py in the matplotlib distribution.

Also borrows liberally from code.py in the Python standard library."""

__author__ = "Fernando Perez <Fer...@co...>"

import sys
import code
import threading

import pygtk
pygtk.require("2.0")
import gtk

try:
    import readline
except ImportError:
    has_readline = False
else:
    has_readline = True

class MTConsole(code.InteractiveConsole):
    """Simple multi-threaded shell"""

    def __init__(self,on_kill=None,*args,**kw):
        code.InteractiveConsole.__init__(self,*args,**kw)
        self.code_to_run = None
        self.ready = threading.Condition()
        self._kill = False
        if on_kill is None:
            on_kill = []
        # Check that all things to kill are callable:
        for _ in on_kill:
            if not callable(_):
                raise TypeError,'on_kill must be a list of callables'
        self.on_kill = on_kill
        # Set up tab-completer
        if has_readline:
            import rlcompleter
            try:  # this form only works with python 2.3
                self.completer = rlcompleter.Completer(self.locals)
            except: # simpler for py2.2
                self.completer = rlcompleter.Completer()
                
            readline.set_completer(self.completer.complete)
            # Use tab for completions
            readline.parse_and_bind('tab: complete')
            # This forces readline to automatically print the above list
when tab
            # completion is set to 'complete'.
            readline.parse_and_bind('set show-all-if-ambiguous on')
            # Bindings for incremental searches in the history. These
searches
            # use the string typed so far on the command line and search
            # anything in the previous input history containing them.
            readline.parse_and_bind('"\C-r": reverse-search-history')
            readline.parse_and_bind('"\C-s": forward-search-history')

    def runsource(self, source, filename="<input>", symbol="single"):
        """Compile and run some source in the interpreter.

        Arguments are as for compile_command().

        One several things can happen:

        1) The input is incorrect; compile_command() raised an
        exception (SyntaxError or OverflowError).  A syntax traceback
        will be printed by calling the showsyntaxerror() method.

        2) The input is incomplete, and more input is required;
        compile_command() returned None.  Nothing happens.

        3) The input is complete; compile_command() returned a code
        object.  The code is executed by calling self.runcode() (which
        also handles run-time exceptions, except for SystemExit).

        The return value is True in case 2, False in the other cases (unless
        an exception is raised).  The return value can be used to
        decide whether to use sys.ps1 or sys.ps2 to prompt the next
        line.
        """
        try:
            code = self.compile(source, filename, symbol)
        except (OverflowError, SyntaxError, ValueError):
            # Case 1
            self.showsyntaxerror(filename)
            return False

        if code is None:
            # Case 2
            return True

        # Case 3
        # Store code in self, so the execution thread can handle it
        self.ready.acquire()
        self.code_to_run = code
        self.ready.wait()  # Wait until processed in timeout interval
        self.ready.release()

        return False

    def runcode(self):
        """Execute a code object.

        When an exception occurs, self.showtraceback() is called to display
a
        traceback."""

        self.ready.acquire()
        if self._kill:
            print 'Closing threads...',
            sys.stdout.flush()
            for tokill in self.on_kill:
                tokill()
            print 'Done.'

        if self.code_to_run is not None:
            self.ready.notify()
            code.InteractiveConsole.runcode(self,self.code_to_run)

        self.code_to_run = None
        self.ready.release()
        return True

    def kill (self):
        """Kill the thread, returning when it has been shut down."""
        self.ready.acquire()
        self._kill = True
        self.ready.release()

class GTKInterpreter(threading.Thread):
    """Run a gtk mainloop() in a separate thread.
    Python commands can be passed to the thread where they will be executed.
    This is implemented by periodically checking for passed code using a
    GTK timeout callback.
    """
    TIMEOUT = 100 # Milisecond interval between timeouts.
    
    def __init__(self,banner=None):
        threading.Thread.__init__(self)
        self.banner = banner
        self.shell = MTConsole(on_kill=[gtk.mainquit])

    def run(self):
        self.pre_interact()
        self.shell.interact(self.banner)
        self.shell.kill()

    def mainloop(self):
        self.start()
        gtk.timeout_add(self.TIMEOUT, self.shell.runcode)
        try:
            if gtk.gtk_version[0] >= 2:
                gtk.threads_init()
        except AttributeError:
            pass
        gtk.mainloop()
        self.join()

    def pre_interact(self):
        """This method should be overridden by subclasses.

        It gets called right before interact(), but after the thread starts.
        Typically used to push initialization code into the interpreter"""
        
        pass

class MatplotLibInterpreter(GTKInterpreter):
    """Threaded interpreter with matplotlib support."""

    def __init__(self,banner=None):
        banner = """\nWelcome to matplotlib, a matlab-like python
environment.
    help(matlab)   -> help on matlab compatible commands from matplotlib.
    help(plotting) -> help on plotting commands.
    """
        GTKInterpreter.__init__(self,banner)
        
    def pre_interact(self):
        """Initialize matplotlib before user interaction begins"""

        push = self.shell.push
        # Code to execute in user's namespace
        lines = ["import matplotlib",
                 "matplotlib.use('GTKAgg')",
                 "matplotlib.interactive(1)",
                 "import matplotlib.matlab as matlab",
                 "from matplotlib.matlab import *"]

        map(push,lines)
        
        

        # Execute file if given.
        if len(sys.argv)>1:
            import matplotlib
            matplotlib.interactive(0) # turn off interaction
            fname = sys.argv[1]
            try:
                inFile = file(fname, 'r')
            except IOError:
                print '*** ERROR *** Could not read file <%s>' % fname
            else:
                print '*** Executing file <%s>:' % fname
                for line in inFile:
                    if line.lstrip().find('show()')==0: continue
                    print '>>', line,
                    push(line)
                inFile.close()
            matplotlib.interactive(1)   # turn on interaction

if __name__ == '__main__':
    # Quick sys.argv hack to extract the option and leave filenames in
sys.argv.
    # For real option handling, use optparse or getopt.
    if len(sys.argv) > 1 and sys.argv[1]=='-mplot':
        sys.argv = [sys.argv[0]]+sys.argv[2:]
        MatplotLibInterpreter().mainloop()
    else:
        GTKInterpreter().mainloop()

>>>>> "Thomas" == Thomas Barket <tho...@ya...> writes:

    Thomas> John, That makes sense.  Tks vm.

    Thomas> I am still confused on what approach needs to be taken to
    Thomas> get the data grids to be *interactive* from the python
    Thomas> command prompt.  It seems to me that such interactivity
    Thomas> requires threading (ie, creating any new data grid gui
    Thomas> window in its own thread).  Is that correct, or is there
    Thomas> some other way to do it?

OK, I appreciate that it's confusing.  It's not an easy subject.  I
suggest you give http://matplotlib.sourceforge.net/interactive.html
and http://matplotlib.sourceforge.net/faq.html#SHOW another reading
because your comments below indicate you haven't fully digested that
material.  I take full responsibility for this, however, because I
wrote the docs!

I'll elaborate somewhat.

First a reminder which I think you already understand: matplotlib has
an interactive mode and a non-interactive mode.  You want to use the
interactive mode, set 'interactive : True' in your rc file.  In
interactive mode do not call show, ever.  OK.

Your real problem is how to start the mainloop vis-a-vis threading.
The answer is (for gtk/gtkagg), use a custom python shell for pygtk.
The idea here is that the custom shell starts the mainloop for you.
When you import matplotlib with interactive on from one of these
shells, the mainloop is already started in a separate thread, and you
can issue plot commands and get immediate responses without losing
control of the prompt.  Of course, you can launch other gtk windows
and widgets too.

There are a variety of python shells out there for pygtk, but I
strongly recommend you start with Fernando Perez's pyint-gtk.py.  
If you notice in my last post to you, I wrote

  > Here is an example using Fernando's ipython-gtk
                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  > hunter:~/python/examples/pygtk> python ~/tmp/ip/ipython-gtk.py
  > Python 2.3.2 (#1, Oct 13 2003, 11:33:15)
  > [GCC 3.3.1] on linux2
  > Type "copyright", "credits" or "license" for more information.
  > (MatplotlibShell)

  > 1 >>> from matplotlib.numerix import rand
  > 2 >>> from array_to_grid import view_array
  > 3 >>> view_array( rand(20,10))
  > Out[3]: <ArrayView object (GtkWindow) at 0x4136db94>

I would have emphasized that but I wrongly assumed you knew you needed
a threaded GTK shell.  I guess I've been doing this too long :-)

pyint-gtk.py is just a temporary proof-of-concept to lay the
groundwork for ipython-gtk, which will be a full featured ipython
shell with gtk/matplotlib support.  If you haven't checked out
ipython, you should, as it's *very nice* for interactive work.
Nonetheless, the current release of ipython doesn't support
gtk/matplotlib, and pyint-gtk.py is as good as the standard shell.
Plus we need testers, because the guts of this shell will become the
guts of ipython-gtk.

If you start it with 

  > python pyint-gtk.py -mplot 

it will not only start the gtk mainloop but will import all of
matplotlib, so if the first command you type is

  >>> plot([1,2,3[])

a plot will pop up.  And you can import and use the view_array code I
posted before as well.

I'll include the src for pyint-gtk.py here, as it is short

Hope this helps,
JDH

#!/usr/bin/env python
"""Multithreaded interactive interpreter with GTK and Matplotlib support.

Usage:

  pyint-gtk.py -> starts shell with gtk thread running separately

  pyint-gtk.py -mplot [filename] -> initializes matplotlib, optionally running
  the named file.  The shell starts after the file is executed.

Threading code inspired by:
http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by Brian
McErlean and John Finlay.

Matplotlib support taken from interactive.py in the matplotlib distribution.

Also borrows liberally from code.py in the Python standard library."""

__author__ = "Fernando Perez <Fer...@co...>"

import sys
import code
import threading

import pygtk
pygtk.require("2.0")
import gtk

try:
    import readline
except ImportError:
    has_readline = False
else:
    has_readline = True

class MTConsole(code.InteractiveConsole):
    """Simple multi-threaded shell"""

    def __init__(self,on_kill=None,*args,**kw):
        code.InteractiveConsole.__init__(self,*args,**kw)
        self.code_to_run = None
        self.ready = threading.Condition()
        self._kill = False
        if on_kill is None:
            on_kill = []
        # Check that all things to kill are callable:
        for _ in on_kill:
            if not callable(_):
                raise TypeError,'on_kill must be a list of callables'
        self.on_kill = on_kill
        # Set up tab-completer
        if has_readline:
            import rlcompleter
            try:  # this form only works with python 2.3
                self.completer = rlcompleter.Completer(self.locals)
            except: # simpler for py2.2
                self.completer = rlcompleter.Completer()
                
            readline.set_completer(self.completer.complete)
            # Use tab for completions
            readline.parse_and_bind('tab: complete')
            # This forces readline to automatically print the above list when tab
            # completion is set to 'complete'.
            readline.parse_and_bind('set show-all-if-ambiguous on')
            # Bindings for incremental searches in the history. These searches
            # use the string typed so far on the command line and search
            # anything in the previous input history containing them.
            readline.parse_and_bind('"\C-r": reverse-search-history')
            readline.parse_and_bind('"\C-s": forward-search-history')

    def runsource(self, source, filename="<input>", symbol="single"):
        """Compile and run some source in the interpreter.

        Arguments are as for compile_command().

        One several things can happen:

        1) The input is incorrect; compile_command() raised an
        exception (SyntaxError or OverflowError).  A syntax traceback
        will be printed by calling the showsyntaxerror() method.

        2) The input is incomplete, and more input is required;
        compile_command() returned None.  Nothing happens.

        3) The input is complete; compile_command() returned a code
        object.  The code is executed by calling self.runcode() (which
        also handles run-time exceptions, except for SystemExit).

        The return value is True in case 2, False in the other cases (unless
        an exception is raised).  The return value can be used to
        decide whether to use sys.ps1 or sys.ps2 to prompt the next
        line.
        """
        try:
            code = self.compile(source, filename, symbol)
        except (OverflowError, SyntaxError, ValueError):
            # Case 1
            self.showsyntaxerror(filename)
            return False

        if code is None:
            # Case 2
            return True

        # Case 3
        # Store code in self, so the execution thread can handle it
        self.ready.acquire()
        self.code_to_run = code
        self.ready.wait()  # Wait until processed in timeout interval
        self.ready.release()

        return False

    def runcode(self):
        """Execute a code object.

        When an exception occurs, self.showtraceback() is called to display a
        traceback."""

        self.ready.acquire()
        if self._kill:
            print 'Closing threads...',
            sys.stdout.flush()
            for tokill in self.on_kill:
                tokill()
            print 'Done.'

        if self.code_to_run is not None:
            self.ready.notify()
            code.InteractiveConsole.runcode(self,self.code_to_run)

        self.code_to_run = None
        self.ready.release()
        return True

    def kill (self):
        """Kill the thread, returning when it has been shut down."""
        self.ready.acquire()
        self._kill = True
        self.ready.release()

class GTKInterpreter(threading.Thread):
    """Run a gtk mainloop() in a separate thread.
    Python commands can be passed to the thread where they will be executed.
    This is implemented by periodically checking for passed code using a
    GTK timeout callback.
    """
    TIMEOUT = 100 # Milisecond interval between timeouts.
    
    def __init__(self,banner=None):
        threading.Thread.__init__(self)
        self.banner = banner
        self.shell = MTConsole(on_kill=[gtk.mainquit])

    def run(self):
        self.pre_interact()
        self.shell.interact(self.banner)
        self.shell.kill()

    def mainloop(self):
        self.start()
        gtk.timeout_add(self.TIMEOUT, self.shell.runcode)
        try:
            if gtk.gtk_version[0] >= 2:
                gtk.threads_init()
        except AttributeError:
            pass
        gtk.mainloop()
        self.join()

    def pre_interact(self):
        """This method should be overridden by subclasses.

        It gets called right before interact(), but after the thread starts.
        Typically used to push initialization code into the interpreter"""
        
        pass

class MatplotLibInterpreter(GTKInterpreter):
    """Threaded interpreter with matplotlib support."""

    def __init__(self,banner=None):
        banner = """\nWelcome to matplotlib, a matlab-like python environment.
    help(matlab)   -> help on matlab compatible commands from matplotlib.
    help(plotting) -> help on plotting commands.
    """
        GTKInterpreter.__init__(self,banner)
        
    def pre_interact(self):
        """Initialize matplotlib before user interaction begins"""

        push = self.shell.push
        # Code to execute in user's namespace
        lines = ["import matplotlib",
                 "matplotlib.use('GTKAgg')",
                 "matplotlib.interactive(1)",
                 "import matplotlib.matlab as matlab",
                 "from matplotlib.matlab import *"]

        map(push,lines)
        
        

        # Execute file if given.
        if len(sys.argv)>1:
            import matplotlib
            matplotlib.interactive(0) # turn off interaction
            fname = sys.argv[1]
            try:
                inFile = file(fname, 'r')
            except IOError:
                print '*** ERROR *** Could not read file <%s>' % fname
            else:
                print '*** Executing file <%s>:' % fname
                for line in inFile:
                    if line.lstrip().find('show()')==0: continue
                    print '>>', line,
                    push(line)
                inFile.close()
            matplotlib.interactive(1)   # turn on interaction

if __name__ == '__main__':
    # Quick sys.argv hack to extract the option and leave filenames in sys.argv.
    # For real option handling, use optparse or getopt.
    if len(sys.argv) > 1 and sys.argv[1]=='-mplot':
        sys.argv = [sys.argv[0]]+sys.argv[2:]
        MatplotLibInterpreter().mainloop()
    else:
        GTKInterpreter().mainloop()

John,

That makes sense.  Tks vm.  

I am still confused on what approach needs to be taken to get the data grids
to be *interactive* from the python command prompt.  It seems to me that
such interactivity requires threading (ie, creating any new data grid gui
window in its own thread).  Is that correct, or is there some other way to
do it?

In fact, with the example below, in order to get it to work, I needed to add
a couple of lines to call the mainloop:

>>> from matplotlib.numerix import rand
>>> from array_to_grid import view_array
>>> view_array( rand(20,10))
<ArrayView object (GtkWindow) at 0x1136eb8>
>>> import gtk
>>> gtk.main()

After I call gtk.main(), I then lose all ability to interact with the python
command prompt :-(.  This gui mainloop concept is something I am a little
confused on.  I understand why one has to call such a mainloop for a gui: so
the gui window can be alerted by the os that some kind of event has been
fired, like a mouse click, so it can respond in the appropriate manner.  But
I don't want to create an application that takes over the mainloop.  I am
not writing a window-driven application.  I want to continue to interact
with the python command prompt (and hopefully be able to interact with any
launched gui windows from it).  So I suppose I have to figure out how to get
such mainloops to run in separate threads (or is "process" the correct word
here???) in order to have access to the python command prompt (and possibly
even create more data grids!).  Is that correct?  Im also a little confused
bc I have read statements like "all graphics commands should be handled in a
single thread."  The "Thinking in Tkinter" web site
(http://www.ferg.org/thinking_in_tkinter/index.html) says:

          Note that you should not run these programs under IDLE.   
          IDLE is itself a Tkinter application, with its own 
          "mainloop" that will conflict with the mainloop in these 
          programs. If you really want to view and run these 
          programs using IDLE, then -- for each program -- you
          should comment out the "mainloop" statement in the 
          program before running it.

That kind of warning sounds a little depressing.  Is it not possible to
(somewhat easily) launch various gui windows, like a data grid, in their own
threads (processes?) and still have control of the python command prompt and
be able to interact with such gui windows?

Any pointers anyone can give me to learn more about launching interactive
gui widgets from the python command prompt and maintaining interactivity
with the python command prompt would be greatly appreciated.  

Many thanks once again.

Sincerely,

Tom

 
-----Original Message-----
From: John Hunter [mailto:jdh...@ac...] 
Sent: Wednesday, August 18, 2004 1:31 PM
To: Thomas Barket
Cc: mat...@li...
Subject: Re: [Matplotlib-users] Requesting advice on multi-threaded
matplotlib session + grids displaying data

>>>>> "Thomas" == Thomas Barket <tho...@ya...> writes:

    Thomas> Btw, what does "TkAgg sets interactive mode to True when
    Thomas> you issue the show command" mean exactly?

It means that if you are using tkagg and issue show, it launches the
interactive interpreter (python shell)

    Thomas> Wx has such a grid widget which can be used for
    Thomas> displaying/editing data, which is what I was hoping to
    Thomas> use.  However, I am not sure if one should mix different
    Thomas> gui's.  Iow, if I use tkagg or gtk as my interactive
    Thomas> matplotlib gui, can I also display and interact with
    Thomas> wxpython grid widgets in the same script smoothly?  Am I
    Thomas> asking for trouble having the same script display
    Thomas> interactive matplotlib charts using one gui type and then
    Thomas> display these grid widgets using another gui type?  Or
    Thomas> should I just stick with one gui type throughout the
    Thomas> entire script so that the interactive matplotlib charts
    Thomas> use say gtk and the same script also uses gtk for its grid
    Thomas> widgets?

OK, now I see better where you are coming from.  You have a deluge of data
coming back from the prompt in the interactive shell and are looking for a
better way to deal with it.  This is really beyond the scope of matplotlib
since it is a plotting library and your question goes more to interacting
with data.  See ipython for solutions to facilitate better interaction with
data.

I can give you a couple of pointers though.

If you save the return value of a plot as a named variable, the output will
be suppressed.  Then you can use array slicing to only show a portion of it.


  1 >>> n, bins, patches = hist(randn(10000), 100) # no output printed
  2 >>> n[:5]  # look at your data in slices using indexing
  Out[2]: [1,1,2,5,3,]

ipython has additional features to automatically suppress really large
arrays

  1 >>> rand(100,100)
  Out[1]: array (100,100) , type = d, has 10000 elements

On to your question about mixing GUIs.  Don't do it.  You will explode.

If you want to display your data in a wx grid, you could use the wxagg
matplotlib backend and write some functions to display the data in a wx
grid.  Eg, if you are working in a shell that supports wx interactive work
(pycrust), you could write a function to display any array or vector in a wx
grid and then call that function interactively.  Fernando is working on an
interactive shell (mentioned
previously) that supports matplotlib/gtk.  Once he gets the kinks worked
out, he plans to support matplotlib/wx as well.

If you want to work in gtk (eg matplotlib/gtkagg) the equivalent to a wx
grid is a treeview/liststore.  You can write functions to pipe arrays into
grids and then display them by calling that function interactively.  Here is
an example using Fernando's ipython-gtk

  hunter:~/python/examples/pygtk> python ~/tmp/ip/ipython-gtk.py
  Extra content at the end of the document
  Python 2.3.2 (#1, Oct 13 2003, 11:33:15)
  [GCC 3.3.1] on linux2
  Type "copyright", "credits" or "license" for more information.
  (MatplotlibShell)

  1 >>> from matplotlib.numerix import rand
  2 >>> from array_to_grid import view_array
  3 >>> view_array( rand(20,10))
  Out[3]: <ArrayView object (GtkWindow) at 0x4136db94>

And this is the screenshot -
http://nitace.bsd.uchicago.edu:8080/files/share/Screenshot-Ipython-gtk.py.pn
g

While it would be possible for us to write functions in matplotlib that
would implement view_array (or something like it) for each of the GUI
backends, allowing you to call this function for tk, wx or gtk, it's really
beyond the scope of matplotlib (we're busy enough trying to plot!).  It's
more in the domain of a matlab / mathematica like integrated scientific
computing environment, another topic near and dear to Fernando's heart.

Here is the code array_to_grid.py - you can do a lot more with treeviews and
liststores, eg make a proper editable spreadsheet interface with scroll bars
in both x and y directions, but this will get you started

'Display an array as a treeview'

import pygtk
pygtk.require('2.0')
import gobject
import gtk
from gtk import gdk

def view_array(X):
    'instantiate an ArrayView instance and show it'
    grid = ArrayView(X)
    grid.show_all()
    return grid
    
class ArrayView(gtk.Window):

    def __init__(self, X):
        gtk.Window.__init__(self)

        self.numRows, self.numCols = X.shape
        self.data = X

        self.set_title('Array display')
        self.set_border_width(8)

        vbox = gtk.VBox(False, 8)
        self.add(vbox)

        sw = gtk.ScrolledWindow()
        sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
        sw.set_policy(gtk.POLICY_NEVER,
                      gtk.POLICY_AUTOMATIC)
        vbox.pack_start(sw, True, True)

        model = self.create_model()

        self.treeview = gtk.TreeView(model)
        self.treeview.set_rules_hint(True)


        sw.add(self.treeview)

        self.add_columns()

        self.set_default_size(640, 480)

        self.add_events(gdk.BUTTON_PRESS_MASK |
                       gdk.KEY_PRESS_MASK|
                       gdk.KEY_RELEASE_MASK)


    def add_columns(self):
        model = self.treeview.get_model()
        renderer = gtk.CellRendererText()

        for i in range(self.numCols):
            column = gtk.TreeViewColumn('%d'%i, gtk.CellRendererText(),
text=i)
            self.treeview.append_column(column)

    def create_model(self):
        types = [gobject.TYPE_DOUBLE]*self.numCols
        store = gtk.ListStore(*types)

        for row in self.data:
            iter = store.append()
            pairs = []
            for i, num in enumerate(row): pairs.extend((i, num))

            store.set(iter, *pairs)
        return store

                                     
if __name__=='__main__':
    from matplotlib.numerix import rand
    view_array(rand(10,10))
    gtk.main()