If you use the excellent networkx package from working with graphs, here's a cool way to use the _repr_svg_ in the IPython Notebook or qtconsole.

In [2]:
import networkx as nx
import matplotlib.pyplot as plt
import StringIO
from matplotlib.figure import Figure

class MyGraph(nx.Graph):
def _repr_svg_(self):
plt.ioff() # turn off interactive mode
fig=plt.figure(figsize=(2,2))
nx.draw_shell(self, ax=ax)
output = StringIO.StringIO()
fig.savefig(output,format='svg')
plt.ion() # turn on interactive mode
return output.getvalue()


Basically, I'm creating a class to use as a harness for networkx graphs so that I don't have to keep plotting them to see what changes have been made to the graph as a result of various operations on the graph (e.g. removing nodes, adding edges). For example,here's a binomial graph:

In [3]:
g=nx.random_graphs.binomial_graph(10,.5)
f=MyGraph(g)
f

Out[3]:

Now, if I remove some edges as shown:

In [4]:
f.remove_nodes_from([0,3,7,5] )
f # this triggers the _repr_svg function in the notebook

Out[4]:

Pretty cool, huh? Now, you can interact with networkx graphs and get quick SVG's the represent those changes. Because I've defined a subclass, then I can do everything I normally do with network graphs.

I'm sure there's a neater way to do this and I'd love to hear it! You can download this notebook on my github site.

Min has come up with a better way to do this without subclassing. I'm including his work below to keep everything in one place.

Let's define a function to render a graph to SVG:

In [5]:
import matplotlib.pyplot as plt
from io import BytesIO

def graph_to_svg(g):
"""return the SVG of a matplotlib figure generated from a graph"""
fig=plt.figure(figsize=(2,2))
nx.draw_shell(g, ax=ax)
output = BytesIO()
fig.savefig(output, format='svg')
plt.close(fig)
return output.getvalue()


And call it:

In [6]:
from IPython.display import display, SVG
display(SVG(graph_to_svg(g)))


Now we can register graph_to_svg as the formatter to be called any time an nx.Graph object is seen:

In [7]:
formatter = get_ipython().display_formatter.formatters['image/svg+xml']
formatter.for_type(nx.Graph, graph_to_svg)


From now on, any time we would return a graph, we will see it as an SVG:

In [8]:
g

Out[8]:

Now, if I remove some edges as shown:

In [9]:
g.remove_nodes_from([0,3,7,5])
g # this triggers the graph_to_svg function in the notebook

Out[9]:

Pretty cool, huh? Now, you can interact with networkx graphs and get quick SVG's the represent those changes, without any subclasses.

Thanks for the input, Min! This is a much cleaner way to accomplish this rendering.