Merge branch 'whatsnew011'

docs/examples/lib/example-demo.py

@@ -0,0 +1,40 b''
+"""A simple interactive demo to illustrate the use of IPython's Demo class.
+
+Any python script can be run as a demo, but that does little more than showing
+it on-screen, syntax-highlighted in one shot.  If you add a little simple
+markup, you can stop at specified intervals and return to the ipython prompt,
+resuming execution later.
+"""
+
+print 'Hello, welcome to an interactive IPython demo.'
+print 'Executing this block should require confirmation before proceeding,'
+print 'unless auto_all has been set to true in the demo object'
+
+# The mark below defines a block boundary, which is a point where IPython will
+# stop execution and return to the interactive prompt.
+# Note that in actual interactive execution, 
+# <demo> --- stop ---
+
+x = 1
+y = 2
+
+# <demo> --- stop ---
+
+# the mark below makes this block as silent
+# <demo> silent
+
+print 'This is a silent block, which gets executed but not printed.'
+
+# <demo> --- stop ---
+# <demo> auto
+print 'This is an automatic block.'
+print 'It is executed without asking for confirmation, but printed.'
+z = x+y
+
+print 'z=',x
+
+# <demo> --- stop ---
+# This is just another normal block.
+print 'z is now:', z
+
+print 'bye!'

docs/source/whatsnew/github-stats-011.txt

@@ -0,0 +1,521 b''
+We closed a total of 510 issues, 225 pull requests and 285 regular issues; this
+is the full list (generated with the script `tools/github_stats.py`). We should
+note that a few of these were made on the 0.10.x series, but we have no
+automatic way of filtering the issues by branch, so this reflects all of our
+development over the last two years, including work already released in 0.10.2:
+
+Pull requests (225):
+
+* `642 <https://github.com/ipython/ipython/issues/642>`_: fix typo in docs/examples/vim/README.rst
+* `631 <https://github.com/ipython/ipython/issues/631>`_: two-way vim-ipython integration
+* `637 <https://github.com/ipython/ipython/issues/637>`_: print is a function, this allows to properly exit ipython
+* `635 <https://github.com/ipython/ipython/issues/635>`_: support html representations in the notebook frontend
+* `639 <https://github.com/ipython/ipython/issues/639>`_: Updating the credits file
+* `628 <https://github.com/ipython/ipython/issues/628>`_: import pexpect from IPython.external in irunner
+* `596 <https://github.com/ipython/ipython/issues/596>`_: Irunner
+* `598 <https://github.com/ipython/ipython/issues/598>`_: Fix templates for CrashHandler
+* `590 <https://github.com/ipython/ipython/issues/590>`_: Desktop
+* `600 <https://github.com/ipython/ipython/issues/600>`_: Fix bug with non-ascii reprs inside pretty-printed lists.
+* `618 <https://github.com/ipython/ipython/issues/618>`_: I617
+* `599 <https://github.com/ipython/ipython/issues/599>`_: Gui Qt example and docs
+* `619 <https://github.com/ipython/ipython/issues/619>`_: manpage update
+* `582 <https://github.com/ipython/ipython/issues/582>`_: Updating sympy profile to match the exec_lines of isympy.
+* `578 <https://github.com/ipython/ipython/issues/578>`_: Check to see if correct source for decorated functions can be displayed
+* `589 <https://github.com/ipython/ipython/issues/589>`_: issue 588
+* `591 <https://github.com/ipython/ipython/issues/591>`_: simulate shell expansion on %run arguments, at least tilde expansion
+* `576 <https://github.com/ipython/ipython/issues/576>`_: Show message about %paste magic on an IndentationError
+* `574 <https://github.com/ipython/ipython/issues/574>`_: Getcwdu
+* `565 <https://github.com/ipython/ipython/issues/565>`_: don't move old config files, keep nagging the user
+* `575 <https://github.com/ipython/ipython/issues/575>`_: Added more docstrings to IPython.zmq.session.
+* `567 <https://github.com/ipython/ipython/issues/567>`_: fix trailing whitespace from reseting indentation
+* `564 <https://github.com/ipython/ipython/issues/564>`_: Command line args in docs
+* `560 <https://github.com/ipython/ipython/issues/560>`_: reorder qt support in kernel
+* `561 <https://github.com/ipython/ipython/issues/561>`_: command-line suggestions
+* `556 <https://github.com/ipython/ipython/issues/556>`_: qt_for_kernel: use matplotlib rcParams to decide between PyQt4 and PySide
+* `557 <https://github.com/ipython/ipython/issues/557>`_: Update usage.py to newapp
+* `555 <https://github.com/ipython/ipython/issues/555>`_: Rm default old config
+* `552 <https://github.com/ipython/ipython/issues/552>`_: update parallel code for py3k
+* `504 <https://github.com/ipython/ipython/issues/504>`_: Updating string formatting
+* `551 <https://github.com/ipython/ipython/issues/551>`_: Make pylab import all configurable
+* `496 <https://github.com/ipython/ipython/issues/496>`_: Qt editing keybindings
+* `550 <https://github.com/ipython/ipython/issues/550>`_: Support v2 PyQt4 APIs and PySide in kernel's GUI support
+* `546 <https://github.com/ipython/ipython/issues/546>`_: doc update
+* `548 <https://github.com/ipython/ipython/issues/548>`_: Fix sympy profile to work with sympy 0.7.
+* `542 <https://github.com/ipython/ipython/issues/542>`_: issue 440
+* `533 <https://github.com/ipython/ipython/issues/533>`_: Remove unused configobj and validate libraries from externals.
+* `538 <https://github.com/ipython/ipython/issues/538>`_: fix various tests on Windows
+* `540 <https://github.com/ipython/ipython/issues/540>`_: support `-pylab` flag with deprecation warning
+* `537 <https://github.com/ipython/ipython/issues/537>`_: Docs update
+* `536 <https://github.com/ipython/ipython/issues/536>`_: `setup.py install` depends on setuptools on Windows
+* `480 <https://github.com/ipython/ipython/issues/480>`_: Get help mid-command
+* `462 <https://github.com/ipython/ipython/issues/462>`_: Str and Bytes traitlets
+* `534 <https://github.com/ipython/ipython/issues/534>`_: Handle unicode properly in IPython.zmq.iostream
+* `527 <https://github.com/ipython/ipython/issues/527>`_: ZMQ displayhook
+* `526 <https://github.com/ipython/ipython/issues/526>`_: Handle asynchronous output in Qt console
+* `528 <https://github.com/ipython/ipython/issues/528>`_: Do not import deprecated functions from external decorators library.
+* `454 <https://github.com/ipython/ipython/issues/454>`_: New BaseIPythonApplication
+* `532 <https://github.com/ipython/ipython/issues/532>`_: Zmq unicode
+* `531 <https://github.com/ipython/ipython/issues/531>`_: Fix Parallel test
+* `525 <https://github.com/ipython/ipython/issues/525>`_: fallback on lsof if otool not found in libedit detection
+* `517 <https://github.com/ipython/ipython/issues/517>`_: Merge IPython.parallel.streamsession into IPython.zmq.session
+* `521 <https://github.com/ipython/ipython/issues/521>`_: use dict.get(key) instead of dict[key] for safety from KeyErrors
+* `492 <https://github.com/ipython/ipython/issues/492>`_: add QtConsoleApp using newapplication
+* `485 <https://github.com/ipython/ipython/issues/485>`_: terminal IPython with newapp
+* `486 <https://github.com/ipython/ipython/issues/486>`_: Use newapp in parallel code
+* `511 <https://github.com/ipython/ipython/issues/511>`_: Add a new line before displaying multiline strings in the Qt console.
+* `509 <https://github.com/ipython/ipython/issues/509>`_: i508
+* `501 <https://github.com/ipython/ipython/issues/501>`_: ignore EINTR in channel loops
+* `495 <https://github.com/ipython/ipython/issues/495>`_: Better selection of Qt bindings when QT_API is not specified
+* `498 <https://github.com/ipython/ipython/issues/498>`_: Check for .pyd as extension for binary files.
+* `494 <https://github.com/ipython/ipython/issues/494>`_: QtConsole zoom adjustments
+* `490 <https://github.com/ipython/ipython/issues/490>`_: fix UnicodeEncodeError writing SVG string to .svg file, fixes #489
+* `491 <https://github.com/ipython/ipython/issues/491>`_: add QtConsoleApp using newapplication
+* `479 <https://github.com/ipython/ipython/issues/479>`_: embed() doesn't load default config
+* `483 <https://github.com/ipython/ipython/issues/483>`_: Links launchpad -> github
+* `419 <https://github.com/ipython/ipython/issues/419>`_: %xdel magic
+* `477 <https://github.com/ipython/ipython/issues/477>`_: Add \n to lines in the log
+* `459 <https://github.com/ipython/ipython/issues/459>`_: use os.system for shell.system in Terminal frontend
+* `475 <https://github.com/ipython/ipython/issues/475>`_: i473
+* `471 <https://github.com/ipython/ipython/issues/471>`_: Add test decorator onlyif_unicode_paths.
+* `474 <https://github.com/ipython/ipython/issues/474>`_: Fix support for raw GTK and WX matplotlib backends.
+* `472 <https://github.com/ipython/ipython/issues/472>`_: Kernel event loop is robust against random SIGINT.
+* `460 <https://github.com/ipython/ipython/issues/460>`_: Share code for magic_edit
+* `469 <https://github.com/ipython/ipython/issues/469>`_: Add exit code when running all tests with iptest.
+* `464 <https://github.com/ipython/ipython/issues/464>`_: Add home directory expansion to IPYTHON_DIR environment variables.
+* `455 <https://github.com/ipython/ipython/issues/455>`_: Bugfix with logger
+* `448 <https://github.com/ipython/ipython/issues/448>`_: Separate out skip_doctest decorator
+* `453 <https://github.com/ipython/ipython/issues/453>`_: Draft of new main BaseIPythonApplication.
+* `452 <https://github.com/ipython/ipython/issues/452>`_: Use list/tuple/dict/set subclass's overridden __repr__ instead of the pretty
+* `398 <https://github.com/ipython/ipython/issues/398>`_: allow toggle of svg/png inline figure format
+* `381 <https://github.com/ipython/ipython/issues/381>`_: Support inline PNGs of matplotlib plots
+* `413 <https://github.com/ipython/ipython/issues/413>`_: Retries and Resubmit (#411 and #412)
+* `370 <https://github.com/ipython/ipython/issues/370>`_: Fixes to the display system
+* `449 <https://github.com/ipython/ipython/issues/449>`_: Fix issue 447 - inspecting old-style classes.
+* `423 <https://github.com/ipython/ipython/issues/423>`_: Allow type checking on elements of List,Tuple,Set traits
+* `400 <https://github.com/ipython/ipython/issues/400>`_: Config5
+* `421 <https://github.com/ipython/ipython/issues/421>`_: Generalise mechanism to put text at the next prompt in the Qt console.
+* `443 <https://github.com/ipython/ipython/issues/443>`_: pinfo code duplication
+* `429 <https://github.com/ipython/ipython/issues/429>`_: add check_pid, and handle stale PID info in ipcluster.
+* `431 <https://github.com/ipython/ipython/issues/431>`_: Fix error message in test_irunner
+* `427 <https://github.com/ipython/ipython/issues/427>`_: handle different SyntaxError messages in test_irunner
+* `424 <https://github.com/ipython/ipython/issues/424>`_: Irunner test failure
+* `430 <https://github.com/ipython/ipython/issues/430>`_: Small parallel doc typo
+* `422 <https://github.com/ipython/ipython/issues/422>`_: Make ipython-qtconsole a GUI script
+* `420 <https://github.com/ipython/ipython/issues/420>`_: Permit kernel std* to be redirected
+* `408 <https://github.com/ipython/ipython/issues/408>`_: History request
+* `388 <https://github.com/ipython/ipython/issues/388>`_: Add Emacs-style kill ring to Qt console
+* `414 <https://github.com/ipython/ipython/issues/414>`_: Warn on old config files
+* `415 <https://github.com/ipython/ipython/issues/415>`_: Prevent prefilter from crashing IPython
+* `418 <https://github.com/ipython/ipython/issues/418>`_: Minor configuration doc fixes
+* `407 <https://github.com/ipython/ipython/issues/407>`_: Update What's new documentation
+* `410 <https://github.com/ipython/ipython/issues/410>`_: Install notebook frontend
+* `406 <https://github.com/ipython/ipython/issues/406>`_: install IPython.zmq.gui
+* `393 <https://github.com/ipython/ipython/issues/393>`_: ipdir unicode
+* `397 <https://github.com/ipython/ipython/issues/397>`_: utils.io.Term.cin/out/err -> utils.io.stdin/out/err
+* `389 <https://github.com/ipython/ipython/issues/389>`_: DB fixes and Scheduler HWM
+* `374 <https://github.com/ipython/ipython/issues/374>`_: Various Windows-related fixes to IPython.parallel
+* `362 <https://github.com/ipython/ipython/issues/362>`_: fallback on defaultencoding if filesystemencoding is None
+* `382 <https://github.com/ipython/ipython/issues/382>`_: Shell's reset method clears namespace from last %run command.
+* `385 <https://github.com/ipython/ipython/issues/385>`_: Update iptest exclusions (fix #375)
+* `383 <https://github.com/ipython/ipython/issues/383>`_: Catch errors in querying readline which occur with pyreadline.
+* `373 <https://github.com/ipython/ipython/issues/373>`_: Remove runlines etc.
+* `364 <https://github.com/ipython/ipython/issues/364>`_: Single output
+* `372 <https://github.com/ipython/ipython/issues/372>`_: Multiline input push
+* `363 <https://github.com/ipython/ipython/issues/363>`_: Issue 125
+* `361 <https://github.com/ipython/ipython/issues/361>`_: don't rely on setuptools for readline dependency check
+* `349 <https://github.com/ipython/ipython/issues/349>`_: Fix %autopx magic
+* `355 <https://github.com/ipython/ipython/issues/355>`_: History save thread
+* `356 <https://github.com/ipython/ipython/issues/356>`_: Usability improvements to history in Qt console
+* `357 <https://github.com/ipython/ipython/issues/357>`_: Exit autocall
+* `353 <https://github.com/ipython/ipython/issues/353>`_: Rewrite quit()/exit()/Quit()/Exit() calls as magic
+* `354 <https://github.com/ipython/ipython/issues/354>`_: Cell tweaks
+* `345 <https://github.com/ipython/ipython/issues/345>`_: Attempt to address (partly) issue ipython/#342 by rewriting quit(), exit(), etc.
+* `352 <https://github.com/ipython/ipython/issues/352>`_: #342: Try to recover as intelligently as possible if user calls magic().
+* `346 <https://github.com/ipython/ipython/issues/346>`_: Dedent prefix bugfix + tests: #142
+* `348 <https://github.com/ipython/ipython/issues/348>`_: %reset doesn't reset prompt number.
+* `347 <https://github.com/ipython/ipython/issues/347>`_: Make ip.reset() work the same in interactive or non-interactive code.
+* `343 <https://github.com/ipython/ipython/issues/343>`_: make readline a dependency on OSX
+* `344 <https://github.com/ipython/ipython/issues/344>`_: restore auto debug behavior
+* `339 <https://github.com/ipython/ipython/issues/339>`_: fix for issue 337: incorrect/phantom tooltips for magics
+* `254 <https://github.com/ipython/ipython/issues/254>`_: newparallel branch (add zmq.parallel submodule)
+* `334 <https://github.com/ipython/ipython/issues/334>`_: Hard reset
+* `316 <https://github.com/ipython/ipython/issues/316>`_: Unicode win process
+* `332 <https://github.com/ipython/ipython/issues/332>`_: AST splitter
+* `325 <https://github.com/ipython/ipython/issues/325>`_: Removetwisted
+* `330 <https://github.com/ipython/ipython/issues/330>`_: Magic pastebin
+* `309 <https://github.com/ipython/ipython/issues/309>`_: Bug tests for GH Issues 238, 284, 306, 307. Skip module machinery if not installed. Known failures reported as 'K'
+* `331 <https://github.com/ipython/ipython/issues/331>`_: Tweak config loader for PyPy compatibility.
+* `319 <https://github.com/ipython/ipython/issues/319>`_: Rewrite code to restore readline history after an action
+* `329 <https://github.com/ipython/ipython/issues/329>`_: Do not store file contents in history when running a .ipy file.
+* `179 <https://github.com/ipython/ipython/issues/179>`_: Html notebook
+* `323 <https://github.com/ipython/ipython/issues/323>`_: Add missing external.pexpect to packages
+* `295 <https://github.com/ipython/ipython/issues/295>`_: Magic local scope
+* `315 <https://github.com/ipython/ipython/issues/315>`_: Unicode magic args
+* `310 <https://github.com/ipython/ipython/issues/310>`_: allow Unicode Command-Line options
+* `313 <https://github.com/ipython/ipython/issues/313>`_: Readline shortcuts
+* `311 <https://github.com/ipython/ipython/issues/311>`_: Qtconsole exit
+* `312 <https://github.com/ipython/ipython/issues/312>`_: History memory
+* `294 <https://github.com/ipython/ipython/issues/294>`_: Issue 290
+* `292 <https://github.com/ipython/ipython/issues/292>`_: Issue 31
+* `252 <https://github.com/ipython/ipython/issues/252>`_: Unicode issues
+* `235 <https://github.com/ipython/ipython/issues/235>`_: Fix history magic command's bugs wrt to full history and add -O option to display full history
+* `236 <https://github.com/ipython/ipython/issues/236>`_: History minus p flag
+* `261 <https://github.com/ipython/ipython/issues/261>`_: Adapt magic commands to new history system.
+* `282 <https://github.com/ipython/ipython/issues/282>`_: SQLite history
+* `191 <https://github.com/ipython/ipython/issues/191>`_: Unbundle external libraries
+* `199 <https://github.com/ipython/ipython/issues/199>`_: Magic arguments
+* `204 <https://github.com/ipython/ipython/issues/204>`_: Emacs completion bugfix
+* `293 <https://github.com/ipython/ipython/issues/293>`_: Issue 133
+* `249 <https://github.com/ipython/ipython/issues/249>`_: Writing unicode characters to a log file. (IPython 0.10.2.git)
+* `283 <https://github.com/ipython/ipython/issues/283>`_: Support for 256-color escape sequences in Qt console
+* `281 <https://github.com/ipython/ipython/issues/281>`_: Refactored and improved Qt console's HTML export facility
+* `237 <https://github.com/ipython/ipython/issues/237>`_: Fix185 (take two)
+* `251 <https://github.com/ipython/ipython/issues/251>`_: Issue 129
+* `278 <https://github.com/ipython/ipython/issues/278>`_: add basic XDG_CONFIG_HOME support
+* `275 <https://github.com/ipython/ipython/issues/275>`_: inline pylab cuts off labels on log plots
+* `280 <https://github.com/ipython/ipython/issues/280>`_: Add %precision magic
+* `259 <https://github.com/ipython/ipython/issues/259>`_: Pyside support
+* `193 <https://github.com/ipython/ipython/issues/193>`_: Make ipython cProfile-able
+* `272 <https://github.com/ipython/ipython/issues/272>`_: Magic examples
+* `219 <https://github.com/ipython/ipython/issues/219>`_: Doc magic pycat
+* `221 <https://github.com/ipython/ipython/issues/221>`_: Doc magic alias
+* `230 <https://github.com/ipython/ipython/issues/230>`_: Doc magic edit
+* `224 <https://github.com/ipython/ipython/issues/224>`_: Doc magic cpaste
+* `229 <https://github.com/ipython/ipython/issues/229>`_: Doc magic pdef
+* `273 <https://github.com/ipython/ipython/issues/273>`_: Docs build
+* `228 <https://github.com/ipython/ipython/issues/228>`_: Doc magic who
+* `233 <https://github.com/ipython/ipython/issues/233>`_: Doc magic cd
+* `226 <https://github.com/ipython/ipython/issues/226>`_: Doc magic pwd
+* `218 <https://github.com/ipython/ipython/issues/218>`_: Doc magic history
+* `231 <https://github.com/ipython/ipython/issues/231>`_: Doc magic reset
+* `225 <https://github.com/ipython/ipython/issues/225>`_: Doc magic save
+* `222 <https://github.com/ipython/ipython/issues/222>`_: Doc magic timeit
+* `223 <https://github.com/ipython/ipython/issues/223>`_: Doc magic colors
+* `203 <https://github.com/ipython/ipython/issues/203>`_: Small typos in zmq/blockingkernelmanager.py
+* `227 <https://github.com/ipython/ipython/issues/227>`_: Doc magic logon
+* `232 <https://github.com/ipython/ipython/issues/232>`_: Doc magic profile
+* `264 <https://github.com/ipython/ipython/issues/264>`_: Kernel logging
+* `220 <https://github.com/ipython/ipython/issues/220>`_: Doc magic edit
+* `268 <https://github.com/ipython/ipython/issues/268>`_: PyZMQ >= 2.0.10
+* `267 <https://github.com/ipython/ipython/issues/267>`_: GitHub Pages (again)
+* `266 <https://github.com/ipython/ipython/issues/266>`_: OSX-specific fixes to the Qt console
+* `255 <https://github.com/ipython/ipython/issues/255>`_: Gitwash typo
+* `265 <https://github.com/ipython/ipython/issues/265>`_: Fix string input2
+* `260 <https://github.com/ipython/ipython/issues/260>`_: Kernel crash with empty history
+* `243 <https://github.com/ipython/ipython/issues/243>`_: New display system
+* `242 <https://github.com/ipython/ipython/issues/242>`_: Fix terminal exit
+* `250 <https://github.com/ipython/ipython/issues/250>`_: always use Session.send
+* `239 <https://github.com/ipython/ipython/issues/239>`_: Makefile command & script for GitHub Pages
+* `244 <https://github.com/ipython/ipython/issues/244>`_: My exit
+* `234 <https://github.com/ipython/ipython/issues/234>`_: Timed history save
+* `217 <https://github.com/ipython/ipython/issues/217>`_: Doc magic lsmagic
+* `215 <https://github.com/ipython/ipython/issues/215>`_: History fix
+* `195 <https://github.com/ipython/ipython/issues/195>`_: Formatters
+* `192 <https://github.com/ipython/ipython/issues/192>`_: Ready colorize bug
+* `198 <https://github.com/ipython/ipython/issues/198>`_: Windows workdir
+* `174 <https://github.com/ipython/ipython/issues/174>`_: Whitespace cleanup
+* `188 <https://github.com/ipython/ipython/issues/188>`_: Version info: update our version management system to use git.
+* `158 <https://github.com/ipython/ipython/issues/158>`_: Ready for merge
+* `187 <https://github.com/ipython/ipython/issues/187>`_: Resolved Print shortcut collision with ctrl-P emacs binding
+* `183 <https://github.com/ipython/ipython/issues/183>`_: cleanup of exit/quit commands for qt console
+* `184 <https://github.com/ipython/ipython/issues/184>`_: Logo added to sphinx docs
+* `180 <https://github.com/ipython/ipython/issues/180>`_: Cleanup old code
+* `171 <https://github.com/ipython/ipython/issues/171>`_: Expose Pygments styles as options
+* `170 <https://github.com/ipython/ipython/issues/170>`_: HTML Fixes
+* `172 <https://github.com/ipython/ipython/issues/172>`_: Fix del method exit test
+* `164 <https://github.com/ipython/ipython/issues/164>`_: Qt frontend shutdown behavior fixes and enhancements
+* `167 <https://github.com/ipython/ipython/issues/167>`_: Added HTML export
+* `163 <https://github.com/ipython/ipython/issues/163>`_: Execution refactor
+* `159 <https://github.com/ipython/ipython/issues/159>`_: Ipy3 preparation
+* `155 <https://github.com/ipython/ipython/issues/155>`_: Ready startup fix
+* `152 <https://github.com/ipython/ipython/issues/152>`_: 0.10.1 sge
+* `151 <https://github.com/ipython/ipython/issues/151>`_: mk_object_info -> object_info
+* `149 <https://github.com/ipython/ipython/issues/149>`_: Simple bug-fix
+
+Regular issues (285):
+
+* `630 <https://github.com/ipython/ipython/issues/630>`_: new.py in pwd prevents ipython from starting
+* `623 <https://github.com/ipython/ipython/issues/623>`_: Execute DirectView commands while running LoadBalancedView tasks
+* `437 <https://github.com/ipython/ipython/issues/437>`_: Users should have autocompletion in the notebook
+* `583 <https://github.com/ipython/ipython/issues/583>`_: update manpages
+* `594 <https://github.com/ipython/ipython/issues/594>`_: irunner command line options defer to file extensions
+* `603 <https://github.com/ipython/ipython/issues/603>`_: Users should see colored text in tracebacks and the pager
+* `597 <https://github.com/ipython/ipython/issues/597>`_: UnicodeDecodeError: 'ascii' codec can't decode byte 0xc2
+* `608 <https://github.com/ipython/ipython/issues/608>`_: Organize and layout buttons in the notebook panel sections
+* `609 <https://github.com/ipython/ipython/issues/609>`_: Implement controls in the Kernel panel section
+* `611 <https://github.com/ipython/ipython/issues/611>`_: Add kernel status widget back to notebook
+* `610 <https://github.com/ipython/ipython/issues/610>`_: Implement controls in the Cell section panel
+* `612 <https://github.com/ipython/ipython/issues/612>`_: Implement Help panel section
+* `621 <https://github.com/ipython/ipython/issues/621>`_: [qtconsole] on windows xp, cannot  PageUp more than once
+* `616 <https://github.com/ipython/ipython/issues/616>`_: Store exit status of last command
+* `605 <https://github.com/ipython/ipython/issues/605>`_: Users should be able to open different notebooks in the cwd
+* `302 <https://github.com/ipython/ipython/issues/302>`_: Users should see a consistent behavior in the Out prompt in the html  notebook
+* `435 <https://github.com/ipython/ipython/issues/435>`_: Notebook should not import anything by default
+* `595 <https://github.com/ipython/ipython/issues/595>`_: qtconsole command issue
+* `588 <https://github.com/ipython/ipython/issues/588>`_: ipython-qtconsole uses 100% CPU
+* `586 <https://github.com/ipython/ipython/issues/586>`_: ? + plot() Command B0rks QTConsole Strangely
+* `585 <https://github.com/ipython/ipython/issues/585>`_: %pdoc throws Errors for classes without __init__ or docstring
+* `584 <https://github.com/ipython/ipython/issues/584>`_:  %pdoc throws TypeError
+* `580 <https://github.com/ipython/ipython/issues/580>`_: Client instantiation AssertionError
+* `569 <https://github.com/ipython/ipython/issues/569>`_: UnicodeDecodeError during startup
+* `572 <https://github.com/ipython/ipython/issues/572>`_: Indented command hits error
+* `573 <https://github.com/ipython/ipython/issues/573>`_: -wthread breaks indented top-level statements
+* `570 <https://github.com/ipython/ipython/issues/570>`_: "--pylab inline" vs. "--pylab=inline"
+* `566 <https://github.com/ipython/ipython/issues/566>`_: Can't use exec_file in config file
+* `562 <https://github.com/ipython/ipython/issues/562>`_: update docs to reflect '--args=values'
+* `558 <https://github.com/ipython/ipython/issues/558>`_: triple quote and %s at beginning of line
+* `554 <https://github.com/ipython/ipython/issues/554>`_: Update 0.11 docs to explain Qt console and how to do a clean install
+* `553 <https://github.com/ipython/ipython/issues/553>`_: embed() fails if config files not installed
+* `8 <https://github.com/ipython/ipython/issues/8>`_: Ensure %gui qt works with new Mayavi and pylab
+* `269 <https://github.com/ipython/ipython/issues/269>`_: Provide compatibility api for IPython.Shell().start().mainloop()
+* `66 <https://github.com/ipython/ipython/issues/66>`_: Update the main What's New document to reflect work on 0.11
+* `549 <https://github.com/ipython/ipython/issues/549>`_: Don't check for 'linux2' value in sys.platform
+* `505 <https://github.com/ipython/ipython/issues/505>`_: Qt windows created within imported functions won't show()
+* `545 <https://github.com/ipython/ipython/issues/545>`_: qtconsole ignores exec_lines
+* `371 <https://github.com/ipython/ipython/issues/371>`_: segfault in qtconsole when kernel quits
+* `377 <https://github.com/ipython/ipython/issues/377>`_: Failure: error (nothing to repeat)
+* `544 <https://github.com/ipython/ipython/issues/544>`_: Ipython qtconsole pylab config issue.
+* `543 <https://github.com/ipython/ipython/issues/543>`_: RuntimeError in completer 
+* `440 <https://github.com/ipython/ipython/issues/440>`_: %run filename autocompletion "The kernel heartbeat has been inactive ... " error
+* `541 <https://github.com/ipython/ipython/issues/541>`_: log_level is broken in the  ipython Application
+* `369 <https://github.com/ipython/ipython/issues/369>`_: windows source install doesn't create scripts correctly
+* `351 <https://github.com/ipython/ipython/issues/351>`_: Make sure that the Windows installer handles the top-level IPython scripts.
+* `512 <https://github.com/ipython/ipython/issues/512>`_: Two displayhooks in zmq
+* `340 <https://github.com/ipython/ipython/issues/340>`_: Make sure that the Windows HPC scheduler support is working for 0.11
+* `98 <https://github.com/ipython/ipython/issues/98>`_: Should be able to get help on an object mid-command
+* `529 <https://github.com/ipython/ipython/issues/529>`_: unicode problem in qtconsole for windows
+* `476 <https://github.com/ipython/ipython/issues/476>`_: Separate input area in Qt Console
+* `175 <https://github.com/ipython/ipython/issues/175>`_: Qt console needs configuration support
+* `156 <https://github.com/ipython/ipython/issues/156>`_: Key history lost when debugging program crash
+* `470 <https://github.com/ipython/ipython/issues/470>`_: decorator: uses deprecated features
+* `30 <https://github.com/ipython/ipython/issues/30>`_: readline in OS X does not have correct key bindings
+* `503 <https://github.com/ipython/ipython/issues/503>`_: merge IPython.parallel.streamsession and IPython.zmq.session
+* `456 <https://github.com/ipython/ipython/issues/456>`_: pathname in document punctuated by dots not slashes
+* `451 <https://github.com/ipython/ipython/issues/451>`_: Allow switching the default image format for inline mpl backend
+* `79 <https://github.com/ipython/ipython/issues/79>`_: Implement more robust handling of config stages in Application
+* `522 <https://github.com/ipython/ipython/issues/522>`_: Encoding problems
+* `524 <https://github.com/ipython/ipython/issues/524>`_: otool should not be unconditionally called on osx
+* `523 <https://github.com/ipython/ipython/issues/523>`_: Get profile and config file inheritance working
+* `519 <https://github.com/ipython/ipython/issues/519>`_: qtconsole --pure: "TypeError: string indices must be integers, not str"
+* `516 <https://github.com/ipython/ipython/issues/516>`_: qtconsole --pure: "KeyError: 'ismagic'"
+* `520 <https://github.com/ipython/ipython/issues/520>`_: qtconsole --pure: "TypeError: string indices must be integers, not str"
+* `450 <https://github.com/ipython/ipython/issues/450>`_: resubmitted tasks sometimes stuck as pending
+* `518 <https://github.com/ipython/ipython/issues/518>`_: JSON serialization problems with ObjectId type (MongoDB)
+* `178 <https://github.com/ipython/ipython/issues/178>`_: Channels should be named for their function, not their socket type
+* `515 <https://github.com/ipython/ipython/issues/515>`_: [ipcluster] termination on os x
+* `510 <https://github.com/ipython/ipython/issues/510>`_: qtconsole: indentation problem printing numpy arrays
+* `508 <https://github.com/ipython/ipython/issues/508>`_: "AssertionError: Missing message part." in ipython-qtconsole --pure
+* `499 <https://github.com/ipython/ipython/issues/499>`_: "ZMQError: Interrupted system call" when saving inline figure
+* `426 <https://github.com/ipython/ipython/issues/426>`_: %edit magic fails in qtconsole
+* `497 <https://github.com/ipython/ipython/issues/497>`_: Don't show info from .pyd files
+* `493 <https://github.com/ipython/ipython/issues/493>`_: QFont::setPointSize: Point size <= 0 (0), must be greater than 0
+* `489 <https://github.com/ipython/ipython/issues/489>`_: UnicodeEncodeError in qt.svg.save_svg
+* `458 <https://github.com/ipython/ipython/issues/458>`_: embed() doesn't load default config
+* `488 <https://github.com/ipython/ipython/issues/488>`_: Using IPython with RubyPython leads to problems with IPython.parallel.client.client.Client.__init()
+* `401 <https://github.com/ipython/ipython/issues/401>`_: Race condition when running lbview.apply() fast multiple times in loop
+* `168 <https://github.com/ipython/ipython/issues/168>`_: Scrub Launchpad links from code, docs
+* `141 <https://github.com/ipython/ipython/issues/141>`_: garbage collection problem (revisited)
+* `59 <https://github.com/ipython/ipython/issues/59>`_: test_magic.test_obj_del fails on win32
+* `457 <https://github.com/ipython/ipython/issues/457>`_: Backgrounded Tasks not Allowed?  (but easy to slip by . . .)
+* `297 <https://github.com/ipython/ipython/issues/297>`_: Shouldn't use pexpect for subprocesses in in-process terminal frontend
+* `110 <https://github.com/ipython/ipython/issues/110>`_: magic to return exit status
+* `473 <https://github.com/ipython/ipython/issues/473>`_: OSX readline detection fails in the debugger
+* `466 <https://github.com/ipython/ipython/issues/466>`_: tests fail without unicode filename support
+* `468 <https://github.com/ipython/ipython/issues/468>`_: iptest script has 0 exit code even when tests fail
+* `465 <https://github.com/ipython/ipython/issues/465>`_: client.db_query() behaves different with SQLite and MongoDB
+* `467 <https://github.com/ipython/ipython/issues/467>`_: magic_install_default_config test fails when there is no .ipython directory
+* `463 <https://github.com/ipython/ipython/issues/463>`_: IPYTHON_DIR (and IPYTHONDIR) don't expand tilde to '~' directory
+* `446 <https://github.com/ipython/ipython/issues/446>`_: Test machinery is imported at normal runtime
+* `438 <https://github.com/ipython/ipython/issues/438>`_: Users should be able to use Up/Down for cell navigation
+* `439 <https://github.com/ipython/ipython/issues/439>`_: Users should be able to copy notebook input and output
+* `291 <https://github.com/ipython/ipython/issues/291>`_: Rename special display methods and put them lower in priority than display functions
+* `447 <https://github.com/ipython/ipython/issues/447>`_: Instantiating classes without __init__ function causes kernel to crash
+* `444 <https://github.com/ipython/ipython/issues/444>`_: Ctrl + t in WxIPython Causes Unexpected Behavior
+* `445 <https://github.com/ipython/ipython/issues/445>`_: qt and console Based Startup Errors
+* `428 <https://github.com/ipython/ipython/issues/428>`_: ipcluster doesn't handle stale pid info well
+* `434 <https://github.com/ipython/ipython/issues/434>`_: 10.0.2 seg fault with rpy2
+* `441 <https://github.com/ipython/ipython/issues/441>`_: Allow running a block of code in a file
+* `432 <https://github.com/ipython/ipython/issues/432>`_: Silent request fails
+* `409 <https://github.com/ipython/ipython/issues/409>`_: Test failure in IPython.lib
+* `402 <https://github.com/ipython/ipython/issues/402>`_: History section of messaging spec is incorrect
+* `88 <https://github.com/ipython/ipython/issues/88>`_: Error when inputting UTF8 CJK characters
+* `366 <https://github.com/ipython/ipython/issues/366>`_: Ctrl-K should kill line and store it, so that Ctrl-y can yank it back
+* `425 <https://github.com/ipython/ipython/issues/425>`_: typo in %gui magic help
+* `304 <https://github.com/ipython/ipython/issues/304>`_: Persistent warnings if old configuration files exist
+* `216 <https://github.com/ipython/ipython/issues/216>`_: crash of ipython when alias is used with %s and echo
+* `412 <https://github.com/ipython/ipython/issues/412>`_: add support to automatic retry of tasks
+* `411 <https://github.com/ipython/ipython/issues/411>`_: add support to continue tasks
+* `417 <https://github.com/ipython/ipython/issues/417>`_: IPython should display things unsorted if it can't sort them
+* `416 <https://github.com/ipython/ipython/issues/416>`_: wrong encode when printing unicode string
+* `376 <https://github.com/ipython/ipython/issues/376>`_: Failing InputsplitterTest
+* `405 <https://github.com/ipython/ipython/issues/405>`_: TraitError in traitlets.py(332) on any input
+* `392 <https://github.com/ipython/ipython/issues/392>`_: UnicodeEncodeError on start
+* `137 <https://github.com/ipython/ipython/issues/137>`_: sys.getfilesystemencoding return value not checked
+* `300 <https://github.com/ipython/ipython/issues/300>`_: Users should be able to manage kernels and kernel sessions from the notebook UI
+* `301 <https://github.com/ipython/ipython/issues/301>`_: Users should have access to working Kernel, Tabs, Edit, Help menus in the notebook
+* `396 <https://github.com/ipython/ipython/issues/396>`_: cursor move triggers a lot of IO access
+* `379 <https://github.com/ipython/ipython/issues/379>`_: Minor doc nit: --paging argument
+* `399 <https://github.com/ipython/ipython/issues/399>`_: Add task queue limit in engine when load-balancing
+* `78 <https://github.com/ipython/ipython/issues/78>`_: StringTask won't take unicode code strings
+* `391 <https://github.com/ipython/ipython/issues/391>`_: MongoDB.add_record() does not work in 0.11dev
+* `365 <https://github.com/ipython/ipython/issues/365>`_: newparallel on Windows
+* `386 <https://github.com/ipython/ipython/issues/386>`_: FAIL: test that pushed functions have access to globals
+* `387 <https://github.com/ipython/ipython/issues/387>`_: Interactively defined functions can't access user namespace
+* `118 <https://github.com/ipython/ipython/issues/118>`_: Snow Leopard ipy_vimserver POLL error
+* `394 <https://github.com/ipython/ipython/issues/394>`_: System escape interpreted in multi-line string
+* `26 <https://github.com/ipython/ipython/issues/26>`_: find_job_cmd is too hasty to fail on Windows
+* `368 <https://github.com/ipython/ipython/issues/368>`_: Installation instructions in dev docs are completely wrong
+* `380 <https://github.com/ipython/ipython/issues/380>`_: qtconsole pager RST - HTML not happening consistently
+* `367 <https://github.com/ipython/ipython/issues/367>`_: Qt console doesn't support ibus input method
+* `375 <https://github.com/ipython/ipython/issues/375>`_: Missing libraries cause ImportError in tests
+* `71 <https://github.com/ipython/ipython/issues/71>`_: temp file errors in iptest IPython.core
+* `350 <https://github.com/ipython/ipython/issues/350>`_: Decide how to handle displayhook being triggered multiple times
+* `360 <https://github.com/ipython/ipython/issues/360>`_: Remove `runlines` method
+* `125 <https://github.com/ipython/ipython/issues/125>`_: Exec lines in config should not contribute to line numbering or history
+* `20 <https://github.com/ipython/ipython/issues/20>`_: Robust readline support on OS X's builtin Python
+* `147 <https://github.com/ipython/ipython/issues/147>`_: On Windows, %page is being too restrictive to split line by \r\n only
+* `326 <https://github.com/ipython/ipython/issues/326>`_: Update docs and examples for parallel stuff to reflect movement away from Twisted
+* `341 <https://github.com/ipython/ipython/issues/341>`_: FIx Parallel Magics for newparallel
+* `338 <https://github.com/ipython/ipython/issues/338>`_: Usability improvements to Qt console
+* `142 <https://github.com/ipython/ipython/issues/142>`_: unexpected auto-indenting when varibles names that start with 'pass' 
+* `296 <https://github.com/ipython/ipython/issues/296>`_: Automatic PDB via %pdb doesn't work
+* `337 <https://github.com/ipython/ipython/issues/337>`_: exit( and quit( in Qt console produces phantom signature/docstring popup, even though quit() or exit() raises NameError
+* `318 <https://github.com/ipython/ipython/issues/318>`_: %debug broken in master: invokes missing save_history() method
+* `307 <https://github.com/ipython/ipython/issues/307>`_: lines ending with semicolon should not go to cache
+* `104 <https://github.com/ipython/ipython/issues/104>`_: have ipengine run start-up scripts before registering with the controller
+* `33 <https://github.com/ipython/ipython/issues/33>`_: The skip_doctest decorator is failing to work on Shell.MatplotlibShellBase.magic_run
+* `336 <https://github.com/ipython/ipython/issues/336>`_: Missing figure development/figs/iopubfade.png for docs
+* `49 <https://github.com/ipython/ipython/issues/49>`_: %clear should also delete _NN references and Out[NN] ones
+* `335 <https://github.com/ipython/ipython/issues/335>`_: using setuptools installs every script twice
+* `306 <https://github.com/ipython/ipython/issues/306>`_: multiline strings at end of input cause noop
+* `327 <https://github.com/ipython/ipython/issues/327>`_: PyPy compatibility
+* `328 <https://github.com/ipython/ipython/issues/328>`_: %run script.ipy raises "ERROR! Session/line number was not unique in database."
+* `7 <https://github.com/ipython/ipython/issues/7>`_: Update the changes doc to reflect the kernel config work
+* `303 <https://github.com/ipython/ipython/issues/303>`_: Users should be able to scroll a notebook w/o moving the menu/buttons
+* `322 <https://github.com/ipython/ipython/issues/322>`_: Embedding an interactive IPython shell 
+* `321 <https://github.com/ipython/ipython/issues/321>`_: %debug broken in master
+* `287 <https://github.com/ipython/ipython/issues/287>`_: Crash when using %macros in sqlite-history branch
+* `55 <https://github.com/ipython/ipython/issues/55>`_: Can't edit files whose names begin with numbers
+* `284 <https://github.com/ipython/ipython/issues/284>`_: In variable no longer works in 0.11
+* `92 <https://github.com/ipython/ipython/issues/92>`_: Using multiprocessing module crashes parallel iPython
+* `262 <https://github.com/ipython/ipython/issues/262>`_: Fail to recover history after force-kill.
+* `320 <https://github.com/ipython/ipython/issues/320>`_: Tab completing re.search objects crashes IPython
+* `317 <https://github.com/ipython/ipython/issues/317>`_: IPython.kernel: parallel map issues
+* `197 <https://github.com/ipython/ipython/issues/197>`_: ipython-qtconsole unicode problem in magic ls
+* `305 <https://github.com/ipython/ipython/issues/305>`_: more readline shortcuts in qtconsole
+* `314 <https://github.com/ipython/ipython/issues/314>`_: Multi-line, multi-block cells can't be executed.
+* `308 <https://github.com/ipython/ipython/issues/308>`_: Test suite should set sqlite history to work in :memory:
+* `202 <https://github.com/ipython/ipython/issues/202>`_: Matplotlib native 'MacOSX' backend broken in '-pylab' mode
+* `196 <https://github.com/ipython/ipython/issues/196>`_: IPython can't deal with unicode file name.
+* `25 <https://github.com/ipython/ipython/issues/25>`_: unicode bug - encoding input
+* `290 <https://github.com/ipython/ipython/issues/290>`_: try/except/else clauses can't be typed, code input stops too early.
+* `43 <https://github.com/ipython/ipython/issues/43>`_: Implement SSH support in ipcluster
+* `6 <https://github.com/ipython/ipython/issues/6>`_: Update the Sphinx docs for the new ipcluster
+* `9 <https://github.com/ipython/ipython/issues/9>`_: Getting "DeadReferenceError: Calling Stale Broker" after ipcontroller restart
+* `132 <https://github.com/ipython/ipython/issues/132>`_: Ipython prevent south from working
+* `27 <https://github.com/ipython/ipython/issues/27>`_: generics.complete_object broken
+* `60 <https://github.com/ipython/ipython/issues/60>`_: Improve absolute import management for iptest.py
+* `31 <https://github.com/ipython/ipython/issues/31>`_: Issues in magic_whos code
+* `52 <https://github.com/ipython/ipython/issues/52>`_: Document testing process better
+* `44 <https://github.com/ipython/ipython/issues/44>`_: Merge history from multiple sessions
+* `182 <https://github.com/ipython/ipython/issues/182>`_: ipython q4thread in version 10.1 not starting properly
+* `143 <https://github.com/ipython/ipython/issues/143>`_: Ipython.gui.wx.ipython_view.IPShellWidget: ignores user*_ns arguments
+* `127 <https://github.com/ipython/ipython/issues/127>`_: %edit does not work on filenames consisted of pure numbers
+* `126 <https://github.com/ipython/ipython/issues/126>`_: Can't transfer command line argument to script
+* `28 <https://github.com/ipython/ipython/issues/28>`_: Offer finer control for initialization of input streams
+* `58 <https://github.com/ipython/ipython/issues/58>`_: ipython change char '0xe9' to 4 spaces
+* `68 <https://github.com/ipython/ipython/issues/68>`_: Problems with Control-C stopping ipcluster on Windows/Python2.6
+* `24 <https://github.com/ipython/ipython/issues/24>`_: ipcluster does not start all the engines
+* `240 <https://github.com/ipython/ipython/issues/240>`_: Incorrect method displayed in %psource
+* `120 <https://github.com/ipython/ipython/issues/120>`_: inspect.getsource fails for functions defined on command line
+* `212 <https://github.com/ipython/ipython/issues/212>`_: IPython ignores exceptions in the first evaulation of class attrs
+* `108 <https://github.com/ipython/ipython/issues/108>`_: ipython disables python logger
+* `100 <https://github.com/ipython/ipython/issues/100>`_: Overzealous introspection
+* `18 <https://github.com/ipython/ipython/issues/18>`_: %cpaste freeze sync frontend
+* `200 <https://github.com/ipython/ipython/issues/200>`_: Unicode error when starting ipython in a folder with non-ascii path
+* `130 <https://github.com/ipython/ipython/issues/130>`_: Deadlock when importing a module that creates an IPython client
+* `134 <https://github.com/ipython/ipython/issues/134>`_: multline block scrolling
+* `46 <https://github.com/ipython/ipython/issues/46>`_: Input to %timeit is not preparsed
+* `285 <https://github.com/ipython/ipython/issues/285>`_: ipcluster local -n 4 fails
+* `205 <https://github.com/ipython/ipython/issues/205>`_: In the Qt console, Tab should insert 4 spaces when not completing
+* `145 <https://github.com/ipython/ipython/issues/145>`_: Bug on MSW sytems: idle can not be set as default IPython editor. Fix Suggested.
+* `77 <https://github.com/ipython/ipython/issues/77>`_: ipython oops in cygwin
+* `121 <https://github.com/ipython/ipython/issues/121>`_: If plot windows are closed via window controls, no more plotting is possible.
+* `111 <https://github.com/ipython/ipython/issues/111>`_: Iterator version of TaskClient.map() that returns results as they become available
+* `109 <https://github.com/ipython/ipython/issues/109>`_: WinHPCLauncher is a hard dependency that causes errors in the test suite
+* `86 <https://github.com/ipython/ipython/issues/86>`_: Make IPython work with multiprocessing
+* `15 <https://github.com/ipython/ipython/issues/15>`_: Implement SGE support in ipcluster
+* `3 <https://github.com/ipython/ipython/issues/3>`_: Implement PBS support in ipcluster
+* `53 <https://github.com/ipython/ipython/issues/53>`_: Internal Python error in the inspect module
+* `74 <https://github.com/ipython/ipython/issues/74>`_: Manager() [from multiprocessing module] hangs ipythonx but not ipython
+* `51 <https://github.com/ipython/ipython/issues/51>`_: Out not working with ipythonx
+* `201 <https://github.com/ipython/ipython/issues/201>`_: use session.send throughout zmq code
+* `115 <https://github.com/ipython/ipython/issues/115>`_: multiline specials not defined in 0.11 branch
+* `93 <https://github.com/ipython/ipython/issues/93>`_: when looping, cursor appears at leftmost point in newline
+* `133 <https://github.com/ipython/ipython/issues/133>`_: whitespace after Source introspection
+* `50 <https://github.com/ipython/ipython/issues/50>`_: Ctrl-C with -gthread on Windows, causes uncaught IOError
+* `65 <https://github.com/ipython/ipython/issues/65>`_: Do not use .message attributes in exceptions, deprecated in 2.6
+* `76 <https://github.com/ipython/ipython/issues/76>`_: syntax error when raise is inside except process
+* `107 <https://github.com/ipython/ipython/issues/107>`_: bdist_rpm causes traceback looking for a non-existant file
+* `113 <https://github.com/ipython/ipython/issues/113>`_: initial magic ? (question mark) fails before wildcard
+* `128 <https://github.com/ipython/ipython/issues/128>`_: Pdb instance has no attribute 'curframe'
+* `139 <https://github.com/ipython/ipython/issues/139>`_: running with -pylab pollutes namespace
+* `140 <https://github.com/ipython/ipython/issues/140>`_: malloc error during tab completion of numpy array member functions starting with 'c'
+* `153 <https://github.com/ipython/ipython/issues/153>`_: ipy_vimserver traceback on Windows
+* `154 <https://github.com/ipython/ipython/issues/154>`_: using ipython in Slicer3 show how os.environ['HOME'] is not defined
+* `185 <https://github.com/ipython/ipython/issues/185>`_: show() blocks in pylab mode with ipython 0.10.1 
+* `189 <https://github.com/ipython/ipython/issues/189>`_: Crash on tab completion
+* `274 <https://github.com/ipython/ipython/issues/274>`_: bashism in sshx.sh
+* `276 <https://github.com/ipython/ipython/issues/276>`_: Calling `sip.setapi` does not work if app has already imported from PyQt4
+* `277 <https://github.com/ipython/ipython/issues/277>`_: matplotlib.image imgshow from 10.1 segfault
+* `288 <https://github.com/ipython/ipython/issues/288>`_: Incorrect docstring in zmq/kernelmanager.py
+* `286 <https://github.com/ipython/ipython/issues/286>`_: Fix IPython.Shell compatibility layer
+* `99 <https://github.com/ipython/ipython/issues/99>`_: blank lines in history
+* `129 <https://github.com/ipython/ipython/issues/129>`_: psearch: TypeError: expected string or buffer
+* `190 <https://github.com/ipython/ipython/issues/190>`_: Add option to format float point output
+* `246 <https://github.com/ipython/ipython/issues/246>`_: Application not conforms XDG Base Directory Specification
+* `48 <https://github.com/ipython/ipython/issues/48>`_: IPython should follow the XDG Base Directory spec for configuration
+* `176 <https://github.com/ipython/ipython/issues/176>`_: Make client-side history persistence readline-independent
+* `279 <https://github.com/ipython/ipython/issues/279>`_: Backtraces when using ipdb do not respect -colour LightBG setting
+* `119 <https://github.com/ipython/ipython/issues/119>`_: Broken type filter in magic_who_ls
+* `271 <https://github.com/ipython/ipython/issues/271>`_: Intermittent problem with print output in Qt console.
+* `270 <https://github.com/ipython/ipython/issues/270>`_: Small typo in IPython developer’s guide
+* `166 <https://github.com/ipython/ipython/issues/166>`_: Add keyboard accelerators to Qt close dialog
+* `173 <https://github.com/ipython/ipython/issues/173>`_: asymmetrical ctrl-A/ctrl-E behavior in multiline
+* `45 <https://github.com/ipython/ipython/issues/45>`_: Autosave history for robustness
+* `162 <https://github.com/ipython/ipython/issues/162>`_: make command history persist in ipythonqt
+* `161 <https://github.com/ipython/ipython/issues/161>`_: make ipythonqt exit without dialog when exit() is called
+* `263 <https://github.com/ipython/ipython/issues/263>`_: [ipython + numpy] Some test errors 
+* `256 <https://github.com/ipython/ipython/issues/256>`_: reset docstring ipython 0.10 
+* `258 <https://github.com/ipython/ipython/issues/258>`_: allow caching to avoid matplotlib object referrences
+* `248 <https://github.com/ipython/ipython/issues/248>`_: Can't open and read files after upgrade from 0.10 to 0.10.0
+* `247 <https://github.com/ipython/ipython/issues/247>`_: ipython + Stackless
+* `245 <https://github.com/ipython/ipython/issues/245>`_: Magic save and macro missing newlines, line ranges don't match prompt numbers.
+* `241 <https://github.com/ipython/ipython/issues/241>`_: "exit" hangs on terminal version of IPython
+* `213 <https://github.com/ipython/ipython/issues/213>`_: ipython -pylab no longer plots interactively on 0.10.1
+* `4 <https://github.com/ipython/ipython/issues/4>`_: wx frontend don't display well commands output
+* `5 <https://github.com/ipython/ipython/issues/5>`_: ls command not supported in ipythonx wx frontend
+* `1 <https://github.com/ipython/ipython/issues/1>`_: Document winhpcjob.py and launcher.py
+* `83 <https://github.com/ipython/ipython/issues/83>`_: Usage of testing.util.DeferredTestCase should be replace with twisted.trial.unittest.TestCase
+* `117 <https://github.com/ipython/ipython/issues/117>`_: Redesign how Component instances are tracked and queried
+* `47 <https://github.com/ipython/ipython/issues/47>`_: IPython.kernel.client cannot be imported inside an engine
+* `105 <https://github.com/ipython/ipython/issues/105>`_: Refactor the task dependencies system
+* `210 <https://github.com/ipython/ipython/issues/210>`_: 0.10.1 doc mistake - New IPython Sphinx directive error
+* `209 <https://github.com/ipython/ipython/issues/209>`_: can't activate IPython parallel magics
+* `206 <https://github.com/ipython/ipython/issues/206>`_: Buggy linewrap in Mac OSX Terminal
+* `194 <https://github.com/ipython/ipython/issues/194>`_: !sudo <command> displays password in plain text
+* `186 <https://github.com/ipython/ipython/issues/186>`_: %edit issue under OS X 10.5 - IPython 0.10.1
+* `11 <https://github.com/ipython/ipython/issues/11>`_: Create a daily build PPA for ipython
+* `144 <https://github.com/ipython/ipython/issues/144>`_: logo missing from sphinx docs
+* `181 <https://github.com/ipython/ipython/issues/181>`_: cls command does not work on windows
+* `169 <https://github.com/ipython/ipython/issues/169>`_: Kernel can only be bound to localhost
+* `36 <https://github.com/ipython/ipython/issues/36>`_: tab completion does not escape ()
+* `177 <https://github.com/ipython/ipython/issues/177>`_: Report tracebacks of interactively entered input
+* `148 <https://github.com/ipython/ipython/issues/148>`_: dictionary having multiple keys having frozenset fails to print on iPython
+* `160 <https://github.com/ipython/ipython/issues/160>`_: magic_gui throws TypeError when gui magic is used
+* `150 <https://github.com/ipython/ipython/issues/150>`_: History entries ending with parentheses corrupt command line on OS X 10.6.4
+* `146 <https://github.com/ipython/ipython/issues/146>`_: -ipythondir - using an alternative .ipython dir for rc type stuff
+* `114 <https://github.com/ipython/ipython/issues/114>`_: Interactive strings get mangled with "_ip.magic"
+* `135 <https://github.com/ipython/ipython/issues/135>`_: crash on  invalid print
+* `69 <https://github.com/ipython/ipython/issues/69>`_: Usage of "mycluster" profile in docs and examples
+* `37 <https://github.com/ipython/ipython/issues/37>`_: Fix colors in output of ResultList on Windows

IPython/core/history.py

@@ -693,7 +693,7 b" def magic_history(self, parameter_s = ''):"
 
 
 def magic_rep(self, arg):
-    r""" Repeat a command, or get command to input line for editing
+    r"""Repeat a command, or get command to input line for editing
 
     - %rep (no arguments):
     

IPython/core/magic.py

@@ -385,20 +385,6 b' IPython ships with automagic on, so you should only rarely need the % escape.'
 Example: typing '%cd mydir' (without the quotes) changes you working directory
 to 'mydir', if it exists.
 
-You can define your own magic functions to extend the system. See the supplied
-ipythonrc and example-magic.py files for details (in your ipython
-configuration directory, typically $HOME/.config/ipython on Linux or $HOME/.ipython elsewhere).
-
-You can also define your own aliased names for magic functions. In your
-ipythonrc file, placing a line like:
-
-  execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
-
-will define %pf as a new name for %profile.
-
-You can also call magics in code using the magic() function, which IPython
-automatically adds to the builtin namespace.  Type 'magic?' for details.
-
 For a list of the available magic functions, use %lsmagic. For a description
 of any of them, type %magic_name?, e.g. '%cd?'.
 

IPython/core/usage.py

@@ -26,7 +26,6 b' Tools for Interactive Computing in Python'
 
 
 Usage
------
 
     ipython [subcommand] [options] [files]
 

IPython/lib/inputhook.py

@@ -115,13 +115,14 b' class InputHookManager(object):'
         elif self._apps.has_key(gui):
             del self._apps[gui]
 
-    def enable_wx(self):
+    def enable_wx(self, app=None):
         """Enable event loop integration with wxPython.
 
         Parameters
         ----------
-        app : bool
-            Create a running application object or not.
+        app : WX Application, optional.
+            Running application to use.  If not given, we probe WX for an
+            existing application object, and create a new one if none is found.
 
         Notes
         -----
@@ -129,22 +130,19 b' class InputHookManager(object):'
         the wxPython to integrate with terminal based applications like
         IPython.
 
-        If ``app`` is True, we create an :class:`wx.App` as follows::
+        If ``app`` is not given we probe for an existing one, and return it if
+        found.  If no existing app is found, we create an :class:`wx.App` as
+        follows::
 
             import wx
             app = wx.App(redirect=False, clearSigInt=False)
-
-        Both options this constructor are important for things to work
-        properly in an interactive context.
-
-        But, we first check to see if an application has already been 
-        created.  If so, we simply return that instance.
         """
         from IPython.lib.inputhookwx import inputhook_wx
         self.set_inputhook(inputhook_wx)
         self._current_gui = GUI_WX
         import wx
-        app = wx.GetApp()
+        if app is None:
+            app = wx.GetApp()
         if app is None:
             app = wx.App(redirect=False, clearSigInt=False)
         app._in_event_loop = True
@@ -160,13 +158,14 b' class InputHookManager(object):'
             self._apps[GUI_WX]._in_event_loop = False
         self.clear_inputhook()
 
-    def enable_qt4(self):
+    def enable_qt4(self, app=None):
         """Enable event loop integration with PyQt4.
         
         Parameters
         ----------
-        app : bool
-            Create a running application object or not.
+        app : Qt Application, optional.
+            Running application to use.  If not given, we probe Qt for an
+            existing application object, and create a new one if none is found.
 
         Notes
         -----
@@ -174,13 +173,12 b' class InputHookManager(object):'
         the PyQt4 to integrate with terminal based applications like
         IPython.
 
-        If ``app`` is True, we create an :class:`QApplication` as follows::
+        If ``app`` is not given we probe for an existing one, and return it if
+        found.  If no existing app is found, we create an :class:`QApplication`
+        as follows::
 
             from PyQt4 import QtCore
             app = QtGui.QApplication(sys.argv)
-
-        But, we first check to see if an application has already been 
-        created.  If so, we simply return that instance.
         """
         from IPython.external.qt_for_kernel import QtCore, QtGui
 
@@ -205,7 +203,8 b' class InputHookManager(object):'
             pass
 
         self._current_gui = GUI_QT4
-        app = QtCore.QCoreApplication.instance()
+        if app is None:
+            app = QtCore.QCoreApplication.instance()
         if app is None:
             app = QtGui.QApplication([" "])
         app._in_event_loop = True
@@ -221,14 +220,15 b' class InputHookManager(object):'
             self._apps[GUI_QT4]._in_event_loop = False
         self.clear_inputhook()
 
-    def enable_gtk(self, app=False):
+    def enable_gtk(self, app=None):
         """Enable event loop integration with PyGTK.
 
         Parameters
         ----------
-        app : bool
-            Create a running application object or not.  Because gtk does't
-            have an app class, this does nothing.
+        app : ignored
+           Ignored, it's only a placeholder to keep the call signature of all
+           gui activation methods consistent, which simplifies the logic of
+           supporting magics.
 
         Notes
         -----
@@ -253,21 +253,24 b' class InputHookManager(object):'
         """
         self.clear_inputhook()
 
-    def enable_tk(self, app=False):
+    def enable_tk(self, app=None):
         """Enable event loop integration with Tk.
 
         Parameters
         ----------
-        app : bool
-            Create a running application object or not.
+        app : toplevel :class:`Tkinter.Tk` widget, optional.
+            Running toplevel widget to use.  If not given, we probe Tk for an
+            existing one, and create a new one if none is found.
 
         Notes
         -----
-        Currently this is a no-op as creating a :class:`Tkinter.Tk` object 
+        If you have already created a :class:`Tkinter.Tk` object, the only
+        thing done by this method is to register with the
+        :class:`InputHookManager`, since creating that object automatically
         sets ``PyOS_InputHook``.
         """
         self._current_gui = GUI_TK
-        if app:
+        if app is None:
             import Tkinter
             app = Tkinter.Tk()
             app.withdraw()
@@ -302,7 +305,7 b' clear_app_refs = inputhook_manager.clear_app_refs'
 
 
 # Convenience function to switch amongst them
-def enable_gui(gui=None):
+def enable_gui(gui=None, app=None):
     """Switch amongst GUI input hooks by name.
 
     This is just a utility wrapper around the methods of the InputHookManager
@@ -314,8 +317,11 b' def enable_gui(gui=None):'
       If None, clears input hook, otherwise it must be one of the recognized
       GUI names (see ``GUI_*`` constants in module).
 
-    app : optional, bool
-      If true, create an app object and return it.
+    app : optional, existing application object.
+      For toolkits that have the concept of a global app, you can supply an
+      existing one.  If not given, the toolkit will be probed for one, and if
+      none is found, a new one will be created.  Note that GTK does not have
+      this concept, and passing an app if `gui`=="GTK" will raise an error.
 
     Returns
     -------
@@ -333,7 +339,7 b' def enable_gui(gui=None):'
     try:
         gui_hook = guis[gui]
     except KeyError:
-        e="Invalid GUI request %r, valid ones are:%s" % (gui, guis.keys())
+        e = "Invalid GUI request %r, valid ones are:%s" % (gui, guis.keys())
         raise ValueError(e)
-    return gui_hook()
+    return gui_hook(app)
 

IPython/utils/io.py

@@ -196,7 +196,7 b" def raw_input_multi(header='', ps1='==> ', ps2='..> ',terminate_str = '.'):"
 
         return lines[:-1]  # don't return the termination command
     except EOFError:
-        print
+        print()
         return lines
 
 
@@ -232,7 +232,7 b' def ask_yes_no(prompt,default=None):'
         except EOFError:
             if default in answers.keys():
                 ans = default
-                print
+                print()
             else:
                 raise
 

IPython/zmq/zmqshell.py

@@ -396,7 +396,7 b' class ZMQInteractiveShell(InteractiveShell):'
 
     def magic_gui(self, *args, **kwargs):
         raise NotImplementedError(
-            'GUI support must be enabled in command line options.')
+            'Kernel GUI support is not implemented yet, except for --pylab.')
 
     def magic_pylab(self, *args, **kwargs):
         raise NotImplementedError(

docs/examples/lib/gui-gtk.py

@@ -8,7 +8,6 b' In [5]: %gui gtk'
 In [6]: %run gui-gtk.py
 """
 
-
 import pygtk
 pygtk.require('2.0')
 import gtk
@@ -38,6 +37,3 b' try:'
     enable_gtk()
 except ImportError:
     gtk.main()
-
-
-

docs/examples/lib/gui-qt.py

@@ -35,6 +35,7 b" if __name__ == '__main__':"
     sw.show()
 
     try:
-        from IPython import enable_qt4; enable_qt4(app)
+        from IPython.lib.guisupport import start_event_loop_qt4
+        start_event_loop_qt4(app)
     except ImportError:
         app.exec_()

docs/examples/lib/gui-tk.py

@@ -27,6 +27,6 b' root = Tk()'
 app = MyApp(root)
 
 try:
-    from IPython import enable_tk; enable_tk(root)
+    from IPython.lib.inputhook import enable_tk; enable_tk(root)
 except ImportError:
     root.mainloop()

docs/examples/lib/gui-wx.py

@@ -1,4 +1,10 b''
-"""A Simple wx example to test IPython's event loop integration.
+#!/usr/bin/env python
+"""
+WARNING: This example is currently broken, see
+https://github.com/ipython/ipython/issues/645 for details on our progress on
+this issue.
+
+A Simple wx example to test IPython's event loop integration.
 
 To run this do:
 
@@ -97,13 +103,19 b' class MyApp(wx.App):'
         frame.Show(True)
         return True
 
-app = wx.GetApp()
-if app is None:
-    app = MyApp(redirect=False, clearSigInt=False)
 
-try:
-    from IPython.lib.inputhook import enable_wx
-    enable_wx(app)
-except ImportError:
-    app.MainLoop()
+if __name__ == '__main__':
+    raise NotImplementedError(
+        'Standalone WX GUI support is currently broken. '
+        'See https://github.com/ipython/ipython/issues/645 for details')
+
+    app = wx.GetApp()
+    if app is None:
+        app = MyApp(redirect=False, clearSigInt=False)
+
+    try:
+        from IPython.lib.inputhook import enable_wx
+        enable_wx(app)
+    except ImportError:
+        app.MainLoop()
 

docs/source/attic/parallel_task_old.txt

@@ -17,7 +17,7 b' use the ``ipcluster`` command::'
 
 	$ ipcluster -n 4
 	
-For more detailed information about starting the controller and engines, see our :ref:`introduction <ip1par>` to using IPython for parallel computing.
+For more detailed information about starting the controller and engines, see our :ref:`introduction <parallel_overview>` to using IPython for parallel computing.
 
 The magic here is that this single controller and set of engines is running both the MultiEngine and ``Task`` interfaces simultaneously.
 

docs/source/development/messaging.txt

@@ -22,7 +22,7 b' within and between hosts.'
    
 The basic design is explained in the following diagram:
 
-.. image:: frontend-kernel.png
+.. image:: figs/frontend-kernel.png
    :width: 450px
    :alt: IPython kernel/frontend messaging architecture.
    :align: center

docs/source/interactive/qtconsole.txt

@@ -1,30 +1,46 b''
 .. _qtconsole:
 
 =========================
-IPython as a QtGUI widget
+A Qt Console for IPython
 =========================
 
-We now have a version of IPython, using the new two-process :ref:`ZeroMQ Kernel <ipythonzmq>`,
-running in a PyQt_ GUI.
+We now have a version of IPython, using the new two-process :ref:`ZeroMQ Kernel
+<ipythonzmq>`, running in a PyQt_ GUI.  This is a very lightweight widget that
+largely feels like a terminal, but provides a number of enhancements only
+possible in a GUI, such as inline figures, proper multiline editing with syntax
+highlighting, graphical calltips, and much more.
 
-Overview
-========
+.. figure:: ../_static/qtconsole.png
+    :width: 400px
+    :alt: IPython Qt console with embedded plots
+    :align: center
+    :target: ../_static/qtconsole.png
 
-The Qt frontend has hand-coded emacs-style bindings for text navigation. This is not yet
-configurable.
+    The Qt console for IPython, using inline matplotlib plots.
 
-.. seealso:: 
+To get acquainted with the Qt console, type `%guiref` to see a quick
+introduction of its main features.
+
+The Qt frontend has hand-coded emacs-style bindings for text navigation. This
+is not yet configurable.
+
+.. tip::
+
+   Since the Qt console tries hard to behave like a terminal, by default it
+   immediately executes single lines of input that are complete.  If you want
+   to force multiline input, hit :key:`Ctrl-Enter` at the end of the first line
+   instead of :key:`Enter`, and it will open a new line for input.  At any
+   point in a multiline block, you can force its execution (without having to
+   go to the bottom) with :key:`Shift-Enter`.
 
-    :ref:`The original IPython-Qt project description. <ipython_qt>`
-    
 ``%loadpy``
 ===========
 
-The new ``%loadpy`` magic takes any python
-script (must end in '.py'), and pastes its contents as your next input, so you can edit it
-before executing. The script may be on your machine, but you can also specify a url, and
-it will download the script from the web. This is particularly useful for playing with
-examples from documentation, such as matplotlib.
+The new ``%loadpy`` magic takes any python script (must end in '.py'), and
+pastes its contents as your next input, so you can edit it before
+executing. The script may be on your machine, but you can also specify a url,
+and it will download the script from the web. This is particularly useful for
+playing with examples from documentation, such as matplotlib.
 
 .. sourcecode:: ipython
 
@@ -44,10 +60,10 b' examples from documentation, such as matplotlib.'
 Pylab
 =====
 
-One of the most exciting features of the new console is embedded matplotlib figures. You
-can use any standard matplotlib GUI backend (Except native MacOSX) to draw the figures,
-and since there is now a two-process model, there is no longer a conflict between user
-input and the drawing eventloop.
+One of the most exciting features of the new console is embedded matplotlib
+figures. You can use any standard matplotlib GUI backend (Except native MacOSX)
+to draw the figures, and since there is now a two-process model, there is no
+longer a conflict between user input and the drawing eventloop.
 
 .. image:: figs/besselj.png
     :width: 519px
@@ -57,11 +73,12 b' input and the drawing eventloop.'
 :func:`display`
 ***************
 
-An additional function, :func:`display`, will be added to the global namespace if you
-specify the ``pylab`` argument. The IPython display system provides a mechanism for
-specifying PNG or SVG (and more) representations of objects for GUI frontends. By default,
-IPython registers convenient PNG and SVG renderers for matplotlib figures, so you can
-embed them in your document by calling :func:`display` on one or more of them. This is
+An additional function, :func:`display`, will be added to the global namespace
+if you specify the ``--pylab`` option at the command line. The IPython display
+system provides a mechanism for specifying PNG or SVG (and more)
+representations of objects for GUI frontends. By default, IPython registers
+convenient PNG and SVG renderers for matplotlib figures, so you can embed them
+in your document by calling :func:`display` on one or more of them. This is
 especially useful for saving_ your work.
 
 .. sourcecode:: ipython
@@ -72,15 +89,36 b' especially useful for saving_ your work.'
     
     In [7]: display(*getfigs()) # embeds all active figures in the qtconsole
 
+If you have a reference to a matplotlib figure object, you can always display
+that specific figure:
+
+.. sourcecode:: ipython
+
+   In [1]: f = figure()
+
+   In [2]: plot(rand(100))
+   Out[2]: [<matplotlib.lines.Line2D at 0x7fc6ac03dd90>]
+
+   In [3]: display(f)
+
+   # Plot is shown here
+
+   In [4]: title('A title')
+   Out[4]: <matplotlib.text.Text at 0x7fc6ac023450>
+
+   In [5]: display(f)
+
+   # Updated plot with title is shown here.
+
 .. _inline:
 
 ``--pylab=inline``
 ******************
 
-If you want to have all of your figures embedded in your session, instead of calling
-:func:`display`, you can specify ``--pylab=inline`` when you start the console,
-and each time you make a plot, it will show up in your document, as if you had
-called :func:`display(fig)`.
+If you want to have all of your figures embedded in your session, instead of
+calling :func:`display`, you can specify ``--pylab=inline`` when you start the
+console, and each time you make a plot, it will show up in your document, as if
+you had called :func:`display(fig)`.
 
 
 .. _saving:
@@ -88,31 +126,32 b' called :func:`display(fig)`.'
 Saving and Printing
 ===================
 
-IPythonQt has the ability to save your current session, as either HTML or XHTML. If you
-have been using :func:`display` or inline_ pylab, your figures will be PNG
-in HTML, or inlined as SVG in XHTML. PNG images have the option to be either in an
-external folder, as in many browsers' "Webpage, Complete" option, or inlined as well, for
-a larger, but more portable file.
+IPythonQt has the ability to save your current session, as either HTML or
+XHTML. If you have been using :func:`display` or inline_ pylab, your figures
+will be PNG in HTML, or inlined as SVG in XHTML. PNG images have the option to
+be either in an external folder, as in many browsers' "Webpage, Complete"
+option, or inlined as well, for a larger, but more portable file.
 
-The widget also exposes the ability to print directly, via the default print shortcut or
-context menu.
+The widget also exposes the ability to print directly, via the default print
+shortcut or context menu.
 
 
 .. Note:: 
 
-    Saving is only available to richtext Qt widgets, which are used by default, but
-    if you pass the ``--plain`` flag, saving will not be available to you.
+    Saving is only available to richtext Qt widgets, which are used by default,
+    but if you pass the ``--plain`` flag, saving will not be available to you.
 
 
-See these examples of :download:`png/html<figs/jn.html>` and :download:`svg/xhtml
-<figs/jn.xhtml>` output. Note that syntax highlighting does not survive export. This is a known
-issue, and is being investigated.
+See these examples of :download:`png/html<figs/jn.html>` and
+:download:`svg/xhtml <figs/jn.xhtml>` output. Note that syntax highlighting
+does not survive export. This is a known issue, and is being investigated.
 
 Colors and Highlighting
 =======================
 
-Terminal IPython has always had some coloring, but never syntax highlighting. There are a
-few simple color choices, specified by the ``colors`` flag or ``%colors`` magic:
+Terminal IPython has always had some coloring, but never syntax
+highlighting. There are a few simple color choices, specified by the ``colors``
+flag or ``%colors`` magic:
 
 * LightBG for light backgrounds
 * Linux for dark backgrounds
@@ -120,26 +159,28 b' few simple color choices, specified by the ``colors`` flag or ``%colors`` magic:'
 
 The Qt widget has full support for the ``colors`` flag used in the terminal shell.
 
-The Qt widget, however, has full syntax highlighting as you type, handled by the
-`pygments`_ library. The ``style`` argument exposes access to any style by name that can
-be found by pygments, and there are several already installed. The ``colors`` argument,
-if unspecified, will be guessed based on the chosen style. Similarly, there are default
-styles associated with each ``colors`` option.
+The Qt widget, however, has full syntax highlighting as you type, handled by
+the `pygments`_ library. The ``style`` argument exposes access to any style by
+name that can be found by pygments, and there are several already
+installed. The ``colors`` argument, if unspecified, will be guessed based on
+the chosen style. Similarly, there are default styles associated with each
+``colors`` option.
 
 
-Screenshot of ``ipython qtconsole --colors=linux``, which uses the 'monokai' theme by
-default:
+Screenshot of ``ipython qtconsole --colors=linux``, which uses the 'monokai'
+theme by default:
 
 .. image:: figs/colors_dark.png
     :width: 627px
     
 .. Note::
 
-    Calling ``ipython qtconsole -h`` will show all the style names that pygments can find
-    on your system.
+    Calling ``ipython qtconsole -h`` will show all the style names that
+    pygments can find on your system.
 
-You can also pass the filename of a custom CSS stylesheet, if you want to do your own
-coloring, via the ``stylesheet`` argument.  The default LightBG stylesheet:
+You can also pass the filename of a custom CSS stylesheet, if you want to do
+your own coloring, via the ``stylesheet`` argument.  The default LightBG
+stylesheet:
 
 .. sourcecode:: css
 
@@ -155,61 +196,68 b' coloring, via the ``stylesheet`` argument. The default LightBG stylesheet:'
 Fonts
 =====
 
-The QtConsole has configurable via the ConsoleWidget. To change these, set the ``font_family``
-or ``font_size`` traits of the ConsoleWidget. For instance, to use 9pt Anonymous Pro::
+The QtConsole has configurable via the ConsoleWidget. To change these, set the
+``font_family`` or ``font_size`` traits of the ConsoleWidget. For instance, to
+use 9pt Anonymous Pro::
 
     $> ipython qtconsole --ConsoleWidget.font_family="Anonymous Pro" --ConsoleWidget.font_size=9
 
 Process Management
 ==================
 
-With the two-process ZMQ model, the frontend does not block input during execution. This
-means that actions can be taken by the frontend while the Kernel is executing, or even
-after it crashes. The most basic such command is via 'Ctrl-.', which restarts the kernel.
-This can be done in the middle of a blocking execution. The frontend can also know, via a
-heartbeat mechanism, that the kernel has died. This means that the frontend can safely
-restart the kernel.
+With the two-process ZMQ model, the frontend does not block input during
+execution. This means that actions can be taken by the frontend while the
+Kernel is executing, or even after it crashes. The most basic such command is
+via 'Ctrl-.', which restarts the kernel.  This can be done in the middle of a
+blocking execution. The frontend can also know, via a heartbeat mechanism, that
+the kernel has died. This means that the frontend can safely restart the
+kernel.
 
 Multiple Consoles
 *****************
 
-Since the Kernel listens on the network, multiple frontends can connect to it.  These
-do not have to all be qt frontends - any IPython frontend can connect and run code.
-When you start ipython qtconsole, there will be an output line, like::
+Since the Kernel listens on the network, multiple frontends can connect to it.
+These do not have to all be qt frontends - any IPython frontend can connect and
+run code.  When you start ipython qtconsole, there will be an output line,
+like::
 
-    To connect another client to this kernel, use:
-    --external --shell=62109 --iopub=62110 --stdin=62111 --hb=62112
+    [IPKernelApp] To connect another client to this kernel, use:
+    [IPKernelApp] --existing --shell=60690 --iopub=44045 --stdin=38323 --hb=41797
 
-Other frontends can connect to your kernel, and share in the execution. This is great for
-collaboration. The `-e` flag is for 'external'. Starting other consoles with that flag
-will not try to start their own, but rather connect to yours. Ultimately, you will not
-have to specify each port individually, but for now this copy-paste method is best.
+Other frontends can connect to your kernel, and share in the execution. This is
+great for collaboration. The `-e` flag is for 'external'. Starting other
+consoles with that flag will not try to start their own, but rather connect to
+yours. Ultimately, you will not have to specify each port individually, but for
+now this copy-paste method is best.
 
-By default (for security reasons), the kernel only listens on localhost, so you can only
-connect multiple frontends to the kernel from your local machine. You can specify to
-listen on an external interface by specifying the ``ip`` argument::
+By default (for security reasons), the kernel only listens on localhost, so you
+can only connect multiple frontends to the kernel from your local machine. You
+can specify to listen on an external interface by specifying the ``ip``
+argument::
 
     $> ipython qtconsole --ip=192.168.1.123
 
-If you specify the ip as 0.0.0.0, that refers to all interfaces, so any computer that can
-see yours can connect to the kernel.
+If you specify the ip as 0.0.0.0, that refers to all interfaces, so any
+computer that can see yours can connect to the kernel.
 
 .. warning::
 
-    Since the ZMQ code currently has no security, listening on an external-facing IP
-    is dangerous.  You are giving any computer that can see you on the network the ability
-    to issue arbitrary shell commands as you on your machine. Be very careful with this.
+    Since the ZMQ code currently has no security, listening on an
+    external-facing IP is dangerous.  You are giving any computer that can see
+    you on the network the ability to issue arbitrary shell commands as you on
+    your machine. Be very careful with this.
 
 
 Stopping Kernels and Consoles
 *****************************
 
-Since there can be many consoles per kernel, the shutdown mechanism and dialog are
-probably more complicated than you are used to. Since you don't always want to shutdown a
-kernel when you close a window, you are given the option to just close the console window
-or also close the Kernel and *all other windows*. Note that this only refers to all other
-*local* windows, as remote Consoles are not allowed to shutdown the kernel, and shutdowns
-do not close Remote consoles (to allow for saving, etc.).
+Since there can be many consoles per kernel, the shutdown mechanism and dialog
+are probably more complicated than you are used to. Since you don't always want
+to shutdown a kernel when you close a window, you are given the option to just
+close the console window or also close the Kernel and *all other windows*. Note
+that this only refers to all other *local* windows, as remote Consoles are not
+allowed to shutdown the kernel, and shutdowns do not close Remote consoles (to
+allow for saving, etc.).
 
 Rules:
 
@@ -222,12 +270,13 b' Rules:'
 Qt and the QtConsole
 ====================
 
-An important part of working with the QtConsole when you are writing your own Qt code is
-to remember that user code (in the kernel) is *not* in the same process as the frontend.
-This means that there is not necessarily any Qt code running in the kernel, and under most
-normal circumstances there isn't. If, however, you specify ``pylab=qt`` at the
-command-line, then there *will* be a :class:`QCoreApplication` instance running in the
-kernel process along with user-code. To get a reference to this application, do:
+An important part of working with the QtConsole when you are writing your own
+Qt code is to remember that user code (in the kernel) is *not* in the same
+process as the frontend.  This means that there is not necessarily any Qt code
+running in the kernel, and under most normal circumstances there isn't. If,
+however, you specify ``pylab=qt`` at the command-line, then there *will* be a
+:class:`QCoreApplication` instance running in the kernel process along with
+user-code. To get a reference to this application, do:
 
 .. sourcecode:: python
 
@@ -235,9 +284,9 b' kernel process along with user-code. To get a reference to this application, do:'
     app = QtCore.QCoreApplication.instance()
     # app will be None if there is no such instance
 
-A common problem listed in the PyQt4 Gotchas_ is the fact that Python's garbage collection
-will destroy Qt objects (Windows, etc.) once there is no longer a Python reference to
-them, so you have to hold on to them.  For instance, in:
+A common problem listed in the PyQt4 Gotchas_ is the fact that Python's garbage
+collection will destroy Qt objects (Windows, etc.) once there is no longer a
+Python reference to them, so you have to hold on to them.  For instance, in:
 
 .. sourcecode:: python
 
@@ -248,11 +297,11 b' them, so you have to hold on to them. For instance, in:'
         win = QtGui.QMainWindow()
         return win
 
-:func:`make_window` will never draw a window, because garbage collection will destroy it
-before it is drawn, whereas :func:`make_and_return_window` lets the caller decide when the
-window object should be destroyed.  If, as a developer, you know that you always want your
-objects to last as long as the process, you can attach them to the QApplication instance
-itself:
+:func:`make_window` will never draw a window, because garbage collection will
+destroy it before it is drawn, whereas :func:`make_and_return_window` lets the
+caller decide when the window object should be destroyed.  If, as a developer,
+you know that you always want your objects to last as long as the process, you
+can attach them to the QApplication instance itself:
 
 .. sourcecode:: python
     
@@ -272,11 +321,11 b' garbage collected until the application itself is destroyed.'
 Regressions
 ===========
 
-There are some features, where the qt console lags behind the Terminal frontend. We hope
-to have these fixed by 0.11 release.
+There are some features, where the qt console lags behind the Terminal
+frontend. We hope to have these fixed by 0.11 release.
 
-    * !cmd input: Due to our use of pexpect, we cannot pass input to subprocesses launched
-      using the '!' escape. (this will not be fixed).
+* !cmd input: Due to our use of pexpect, we cannot pass input to subprocesses
+   launched using the '!' escape. (this will not be fixed).
 
 .. [PyQt] PyQt4 http://www.riverbankcomputing.co.uk/software/pyqt/download
 .. [pygments] Pygments http://pygments.org/

docs/source/interactive/reference.txt

@@ -325,25 +325,23 b' All options with a [no] prepended can be specified in negated form'
 Interactive use
 ===============
 
-IPython is meant to work as a drop-in
-replacement for the standard interactive interpreter. As such, any code
-which is valid python should execute normally under IPython (cases where
-this is not true should be reported as bugs). It does, however, offer
-many features which are not available at a standard python prompt. What
-follows is a list of these.
+IPython is meant to work as a drop-in replacement for the standard interactive
+interpreter. As such, any code which is valid python should execute normally
+under IPython (cases where this is not true should be reported as bugs). It
+does, however, offer many features which are not available at a standard python
+prompt. What follows is a list of these.
 
 
 Caution for Windows users
 -------------------------
 
-Windows, unfortunately, uses the '\\' character as a path
-separator. This is a terrible choice, because '\\' also represents the
-escape character in most modern programming languages, including
-Python. For this reason, using '/' character is recommended if you
-have problems with ``\``.  However, in Windows commands '/' flags
-options, so you can not use it for the root directory. This means that
-paths beginning at the root must be typed in a contrived manner like:
-``%copy \opt/foo/bar.txt \tmp``
+Windows, unfortunately, uses the '\\' character as a path separator. This is a
+terrible choice, because '\\' also represents the escape character in most
+modern programming languages, including Python. For this reason, using '/'
+character is recommended if you have problems with ``\``.  However, in Windows
+commands '/' flags options, so you can not use it for the root directory. This
+means that paths beginning at the root must be typed in a contrived manner
+like: ``%copy \opt/foo/bar.txt \tmp``
 
 .. _magic:
 
@@ -419,11 +417,11 b' following example defines a new magic command, %impall:'
 
     ip.expose_magic('impall', doimp)
 
-Type %magic for more information, including a list of all available
-magic functions at any time and their docstrings. You can also type
-%magic_function_name? (see sec. 6.4 <#sec:dyn-object-info> for
-information on the '?' system) to get information about any particular
-magic function you are interested in.
+Type `%magic` for more information, including a list of all available magic
+functions at any time and their docstrings. You can also type
+%magic_function_name? (see :ref:`below <dynamic_object_info` for information on
+the '?' system) to get information about any particular magic function you are
+interested in.
 
 The API documentation for the :mod:`IPython.core.magic` module contains the full
 docstrings of all currently available magic commands.
@@ -444,20 +442,20 b' PYTHONDOCS for this feature to work correctly.'
 Dynamic object information
 --------------------------
 
-Typing ?word or word? prints detailed information about an object. If
-certain strings in the object are too long (docstrings, code, etc.) they
-get snipped in the center for brevity. This system gives access variable
-types and values, full source code for any object (if available),
-function prototypes and other useful information.
+Typing ``?word`` or ``word?`` prints detailed information about an object. If
+certain strings in the object are too long (docstrings, code, etc.) they get
+snipped in the center for brevity. This system gives access variable types and
+values, full source code for any object (if available), function prototypes and
+other useful information.
 
-Typing ??word or word?? gives access to the full information without
+Typing ``??word`` or ``word??`` gives access to the full information without
 snipping long strings. Long strings are sent to the screen through the
 less pager if longer than the screen and printed otherwise. On systems
 lacking the less command, IPython uses a very basic internal pager.
 
 The following magic functions are particularly useful for gathering
 information about your working environment. You can get more details by
-typing %magic or querying them individually (use %function_name? with or
+typing ``%magic`` or querying them individually (use %function_name? with or
 without the %), this is just a summary:
 
     * **%pdoc <object>**: Print (or run through a pager if too long) the
@@ -476,21 +474,19 b' without the %), this is just a summary:'
       identifiers and %whos prints a table with some basic details about
       each identifier.
 
-Note that the dynamic object information functions (?/??, %pdoc, %pfile,
-%pdef, %psource) give you access to documentation even on things which
-are not really defined as separate identifiers. Try for example typing
-{}.get? or after doing import os, type os.path.abspath??.
-
+Note that the dynamic object information functions (?/??, ``%pdoc``,
+``%pfile``, ``%pdef``, ``%psource``) give you access to documentation even on
+things which are not really defined as separate identifiers. Try for example
+typing {}.get? or after doing import os, type ``os.path.abspath??``.
 
 .. _readline:
 
 Readline-based features
 -----------------------
 
-These features require the GNU readline library, so they won't work if
-your Python installation lacks readline support. We will first describe
-the default behavior IPython uses, and then how to change it to suit
-your preferences.
+These features require the GNU readline library, so they won't work if your
+Python installation lacks readline support. We will first describe the default
+behavior IPython uses, and then how to change it to suit your preferences.
 
 
 Command line completion
@@ -534,10 +530,10 b' Autoindent'
 IPython can recognize lines ending in ':' and indent the next line,
 while also un-indenting automatically after 'raise' or 'return'.
 
-This feature uses the readline library, so it will honor your ~/.inputrc
-configuration (or whatever file your INPUTRC variable points to). Adding
-the following lines to your .inputrc file can make indenting/unindenting
-more convenient (M-i indents, M-u unindents)::
+This feature uses the readline library, so it will honor your
+:file:`~/.inputrc` configuration (or whatever file your INPUTRC variable points
+to). Adding the following lines to your :file:`.inputrc` file can make
+indenting/unindenting more convenient (M-i indents, M-u unindents)::
 
     $if Python 
     "\M-i": "    "  
@@ -548,17 +544,19 b' Note that there are 4 spaces between the quote marks after "M-i" above.'
 
 .. warning::
 
-    Setting the above indents will cause problems with unicode text entry in the terminal.
+    Setting the above indents will cause problems with unicode text entry in
+    the terminal.
 
 .. warning::
 
-    Autoindent is ON by default, but it can cause problems with
-    the pasting of multi-line indented code (the pasted code gets
-    re-indented on each line). A magic function %autoindent allows you to
-    toggle it on/off at runtime. You can also disable it permanently on in
-    your :file:`ipython_config.py` file (set TerminalInteractiveShell.autoindent=False).
+    Autoindent is ON by default, but it can cause problems with the pasting of
+    multi-line indented code (the pasted code gets re-indented on each line). A
+    magic function %autoindent allows you to toggle it on/off at runtime. You
+    can also disable it permanently on in your :file:`ipython_config.py` file
+    (set TerminalInteractiveShell.autoindent=False).
     
-    If you want to paste multiple lines, it is recommended that you use ``%paste``.
+    If you want to paste multiple lines, it is recommended that you use
+    ``%paste``.
 
 
 Customizing readline behavior
@@ -604,7 +602,7 b' Session logging and restoring'
 -----------------------------
 
 You can log all input from a session either by starting IPython with the
-command line switche ``logfile=foo.py`` (see :ref:`here <command_line_options>`)
+command line switch ``--logfile=foo.py`` (see :ref:`here <command_line_options>`)
 or by activating the logging at any moment with the magic function %logstart.
 
 Log files can later be reloaded by running them as scripts and IPython
@@ -617,10 +615,10 b' any code you wrote while experimenting. Log files are regular text files'
 which you can later open in your favorite text editor to extract code or
 to 'clean them up' before using them to replay a session.
 
-The %logstart function for activating logging in mid-session is used as
-follows:
+The `%logstart` function for activating logging in mid-session is used as
+follows::
 
-%logstart [log_name [log_mode]]
+    %logstart [log_name [log_mode]]
 
 If no name is given, it defaults to a file named 'ipython_log.py' in your
 current working directory, in 'rotate' mode (see below).
@@ -648,7 +646,7 b' System shell access'
 
 Any input line beginning with a ! character is passed verbatim (minus
 the !, of course) to the underlying operating system. For example,
-typing !ls will run 'ls' in the current directory.
+typing ``!ls`` will run 'ls' in the current directory.
 
 Manual capture of command output
 --------------------------------
@@ -702,9 +700,9 b' The %alias magic function and the alias option in the ipythonrc'
 configuration file allow you to define magic functions which are in fact
 system shell commands. These aliases can have parameters.
 
-'%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
+``%alias alias_name cmd`` defines 'alias_name' as an alias for 'cmd'
 
-Then, typing '%alias_name params' will execute the system command 'cmd
+Then, typing ``%alias_name params`` will execute the system command 'cmd
 params' (from your underlying operating system).
 
 You can also define aliases with parameters using %s specifiers (one per
@@ -722,9 +720,8 b' replaced by a positional parameter to the call to %parts::'
 If called with no parameters, %alias prints the table of currently
 defined aliases.
 
-The %rehash/rehashx magics allow you to load your entire $PATH as
-ipython aliases. See their respective docstrings (or sec. 6.2
-<#sec:magic> for further details).
+The %rehashx magic allows you to load your entire $PATH as
+ipython aliases. See its docstring for further details.
 
 
 .. _dreload:
@@ -765,15 +762,14 b' addition to the %rep magic command that brings a history entry'
 up for editing on the next  command line.
 
 The following GLOBAL variables always exist (so don't overwrite them!):
-_i: stores previous input. _ii: next previous. _iii: next-next previous.
-_ih : a list of all input _ih[n] is the input from line n and this list
-is aliased to the global variable In. If you overwrite In with a
-variable of your own, you can remake the assignment to the internal list
-with a simple 'In=_ih'.
+
+* _i, _ii, _iii: store previous, next previous and next-next previous inputs.
+* In, _ih : a list of all inputs; _ih[n] is the input from line n. If you
+  overwrite In with a variable of your own, you can remake the assignment to the
+  internal list with a simple ``In=_ih``.
 
 Additionally, global variables named _i<n> are dynamically created (<n>
-being the prompt counter), such that
-_i<n> == _ih[<n>] == In[<n>].
+being the prompt counter), so ``_i<n> == _ih[<n>] == In[<n>]``.
 
 For example, what you typed at prompt 14 is available as _i14, _ih[14]
 and In[14].
@@ -781,55 +777,23 b' and In[14].'
 This allows you to easily cut and paste multi line interactive prompts
 by printing them out: they print like a clean string, without prompt
 characters. You can also manipulate them like regular variables (they
-are strings), modify or exec them (typing 'exec _i9' will re-execute the
-contents of input prompt 9, 'exec In[9:14]+In[18]' will re-execute lines
-9 through 13 and line 18).
+are strings), modify or exec them (typing ``exec _i9`` will re-execute the
+contents of input prompt 9.
 
 You can also re-execute multiple lines of input easily by using the
 magic %macro function (which automates the process and allows
 re-execution without having to type 'exec' every time). The macro system
 also allows you to re-execute previous lines which include magic
-function calls (which require special processing). Type %macro? or see
-sec. 6.2 <#sec:magic> for more details on the macro system.
+function calls (which require special processing). Type %macro? for more details
+on the macro system.
 
 A history function %hist allows you to see any part of your input
 history by printing a range of the _i variables.
 
 You can also search ('grep') through your history by typing 
-'%hist -g somestring'. This also searches through the so called *shadow history*,
-which remembers all the commands (apart from multiline code blocks)
-you have ever entered. Handy for searching for svn/bzr URL's, IP adrresses
-etc. You can bring shadow history entries listed by '%hist -g' up for editing 
-(or re-execution by just pressing ENTER) with %rep command. Shadow history 
-entries are not available as _iNUMBER variables, and they are identified by 
-the '0' prefix in %hist -g output. That is, history entry 12 is a normal 
-history entry, but 0231 is a shadow history entry.
-
-Shadow history was added because the readline history is inherently very
-unsafe - if you have multiple IPython sessions open, the last session 
-to close will overwrite the history of previountly closed session. Likewise,
-if a crash occurs, history is never saved, whereas shadow history entries
-are added after entering every command (so a command executed 
-in another IPython session is immediately available in other IPython 
-sessions that are open).
-
-To conserve space, a command can exist in shadow history only once - it doesn't 
-make sense to store a common line like "cd .." a thousand times. The idea is 
-mainly to provide a reliable place where valuable, hard-to-remember commands can 
-always be retrieved, as opposed to providing an exact sequence of commands
-you have entered in actual order.
-
-Because shadow history has all the commands you have ever executed,
-time taken by %hist -g will increase oven time. If it ever starts to take
-too long (or it ends up containing sensitive information like passwords), 
-clear the shadow history by `%clear shadow_nuke`.
-
-Time taken to add entries to shadow history should be negligible, but 
-in any case, if you start noticing performance degradation after using 
-IPython for a long time (or running a script that floods the shadow history!), 
-you can 'compress' the shadow history by executing 
-`%clear shadow_compress`. In practice, this should never be necessary
-in normal use.
+``%hist -g somestring``. This is handy for searching for URLs, IP addresses,
+etc. You can bring history entries listed by '%hist -g' up for editing
+with the %recall command, or run them immediately with %rerun.
 
 .. _output_caching:
 
@@ -874,7 +838,7 b' Directory history'
 
 Your history of visited directories is kept in the global list _dh, and
 the magic %cd command can be used to go to any entry in that list. The
-%dhist command allows you to view this history. Do ``cd -<TAB`` to
+%dhist command allows you to view this history. Do ``cd -<TAB>`` to
 conveniently view the directory history.
 
 
@@ -1106,68 +1070,69 b" supplied, which we will briefly describe now. These can be used 'as is'"
 (and both provide very useful functionality), or you can use them as a
 starting point for writing your own extensions.
 
+.. _pasting_with_prompts:
 
-Pasting of code starting with '>>> ' or '... '
-----------------------------------------------
+Pasting of code starting with Python or IPython prompts
+-------------------------------------------------------
 
-In the python tutorial it is common to find code examples which have
-been taken from real python sessions. The problem with those is that all
-the lines begin with either '>>> ' or '... ', which makes it impossible
-to paste them all at once. One must instead do a line by line manual
-copying, carefully removing the leading extraneous characters.
+IPython is smart enough to filter  out input prompts, be they plain Python ones
+(``>>>`` and ``...``) or IPython ones (``In [N]:`` and `` ...:``).  You can
+therefore copy and paste from existing interactive sessions without worry.
 
-This extension identifies those starting characters and removes them
-from the input automatically, so that one can paste multi-line examples
-directly into IPython, saving a lot of time. Please look at the file
-InterpreterPasteInput.py in the IPython/extensions directory for details
-on how this is done.
+The following is a 'screenshot' of how things work, copying an example from the
+standard Python tutorial::
 
-IPython comes with a special profile enabling this feature, called
-tutorial. Simply start IPython via 'ipython -p tutorial' and the feature
-will be available. In a normal IPython session you can activate the
-feature by importing the corresponding module with:
-In [1]: import IPython.extensions.InterpreterPasteInput
+    In [1]: >>> # Fibonacci series:
 
-The following is a 'screenshot' of how things work when this extension
-is on, copying an example from the standard tutorial::
+    In [2]: ... # the sum of two elements defines the next
 
-    IPython profile: tutorial 
+    In [3]: ... a, b = 0, 1
 
-    *** Pasting of code with ">>>" or "..." has been enabled. 
+    In [4]: >>> while b < 10:
+       ...:     ...     print b
+       ...:     ...     a, b = b, a+b
+       ...:     
+    1
+    1
+    2
+    3
+    5
+    8
 
-    In [1]: >>> def fib2(n): # return Fibonacci series up to n 
-       ...: ...     """Return a list containing the Fibonacci series up to
-    n.""" 
-       ...: ...     result = [] 
-       ...: ...     a, b = 0, 1 
-       ...: ...     while b < n: 
-       ...: ...         result.append(b)    # see below 
-       ...: ...         a, b = b, a+b 
-       ...: ...     return result 
-       ...: 
+And pasting from IPython sessions works equally well::
 
-    In [2]: fib2(10) 
-    Out[2]: [1, 1, 2, 3, 5, 8]
+    In [1]: In [5]: def f(x):
+       ...:        ...:     "A simple function"
+       ...:        ...:     return x**2
+       ...:    ...: 
 
-Note that as currently written, this extension does not recognize
-IPython's prompts for pasting. Those are more complicated, since the
-user can change them very easily, they involve numbers and can vary in
-length. One could however extract all the relevant information from the
-IPython instance and build an appropriate regular expression. This is
-left as an exercise for the reader.
+    In [2]: f(3)
+    Out[2]: 9
 
 .. _gui_support:
 
-GUI event loop support support
-==============================
+GUI event loop support
+======================
 
 .. versionadded:: 0.11
     The ``%gui`` magic and :mod:`IPython.lib.inputhook`.
 
+.. warning::
+
+   All GUI support with the ``%gui`` magic, described in this section, applies
+   only to the plain terminal IPython, *not* to the Qt console.  The Qt console
+   currently only supports GUI interaction via the ``--pylab`` flag, as
+   explained :ref:`in the matplotlib section <matplotlib_support>`.
+
+   We intend to correct this limitation as soon as possible, you can track our
+   progress at issue #643_.
+
+.. _643: https://github.com/ipython/ipython/issues/643
+    
 IPython has excellent support for working interactively with Graphical User
 Interface (GUI) toolkits, such as wxPython, PyQt4, PyGTK and Tk. This is
 implemented using Python's builtin ``PyOSInputHook`` hook. This implementation
-is extremely robust compared to our previous threaded based version. The
+is extremely robust compared to our previous thread-based version. The
 advantages of this are:
 
 * GUIs can be enabled and disabled dynamically at runtime.
@@ -1179,46 +1144,46 b' advantages of this are:'
 For users, enabling GUI event loop integration is simple.  You simple use the
 ``%gui`` magic as follows::
 
-    %gui [-a] [GUINAME]
+    %gui [GUINAME]
 
 With no arguments, ``%gui`` removes all GUI support.  Valid ``GUINAME``
-arguments are ``wx``, ``qt4``, ``gtk`` and ``tk``.  The ``-a`` option will
-create and return a running application object for the selected GUI toolkit.
+arguments are ``wx``, ``qt4``, ``gtk`` and ``tk``.
 
 Thus, to use wxPython interactively and create a running :class:`wx.App`
 object, do::
 
-    %gui -a wx
+    %gui wx
 
 For information on IPython's Matplotlib integration (and the ``pylab`` mode)
 see :ref:`this section <matplotlib_support>`.
 
-For developers that want to use IPython's GUI event loop integration in
-the form of a library, these capabilities are exposed in library form
-in the :mod:`IPython.lib.inputhook`.  Interested developers should see the
-module docstrings for more information, but there are a few points that
-should be mentioned here.
+For developers that want to use IPython's GUI event loop integration in the
+form of a library, these capabilities are exposed in library form in the
+:mod:`IPython.lib.inputhook` and :mod:`IPython.lib.guisupport` modules.
+Interested developers should see the module docstrings for more information,
+but there are a few points that should be mentioned here.
 
 First, the ``PyOSInputHook`` approach only works in command line settings 
-where readline is activated.
+where readline is activated.  As indicated in the warning above, we plan on
+improving the integration of GUI event loops with the standalone kernel used by
+the Qt console and other frontends (issue 643_).
 
 Second, when using the ``PyOSInputHook`` approach, a GUI application should
 *not* start its event loop. Instead all of this is handled by the
 ``PyOSInputHook``. This means that applications that are meant to be used both
 in IPython and as standalone apps need to have special code to detects how the
-application is being run. We highly recommend using IPython's
-:func:`enable_foo` functions for this. Here is a simple example that shows the
-recommended code that should be at the bottom of a wxPython using GUI
-application::
+application is being run. We highly recommend using IPython's support for this.
+Since the details vary slightly between toolkits, we point you to the various
+examples in our source directory :file:`docs/examples/lib` that demonstrate
+these capabilities.
 
-  try:
-      from IPython.lib.inputhook import enable_wx
-      enable_wx(app)
-  except ImportError:
-      app.MainLoop()
+.. warning::
+
+   The WX version of this is currently broken.  While ``--pylab=wx`` works
+   fine, standalone WX apps do not.  See
+   https://github.com/ipython/ipython/issues/645 for details of our progress on
+   this issue.
 
-This pattern should be used instead of the simple ``app.MainLoop()`` code
-that a standalone wxPython application would have.
 
 Third, unlike previous versions of IPython, we no longer "hijack" (replace
 them with no-ops) the event loops. This is done to allow applications that
@@ -1233,7 +1198,7 b' PyQt and PySide'
 
 .. attempt at explanation of the complete mess that is Qt support
 
-When you use ``gui=qt`` or ``pylab=qt``, IPython can work with either
+When you use ``--gui=qt`` or ``--pylab=qt``, IPython can work with either
 PyQt4 or PySide.  There are three options for configuration here, because
 PyQt4 has two APIs for QString and QVariant - v1, which is the default on
 Python 2, and the more natural v2, which is the only API supported by PySide.
@@ -1251,21 +1216,20 b' PyQt4 to use its v2 API. So if ``QT_API=pyside`` PySide will be used,'
 and if ``QT_API=pyqt`` then PyQt4 will be used *with the v2 API* for
 QString and QVariant, so ETS codes like MayaVi will also work with IPython.
 
-If you launch IPython in pylab mode with ``ipython pylab=qt``, then IPython
-will ask matplotlib which Qt library to use (only if QT_API is *not set*),
-via the 'backend.qt4' rcParam.
-If matplotlib is version 1.0.1 or older, then IPython will always use PyQt4
-without setting the v2 APIs, since neither v2 PyQt nor PySide work.
+If you launch IPython in pylab mode with ``ipython --pylab=qt``, then IPython
+will ask matplotlib which Qt library to use (only if QT_API is *not set*), via
+the 'backend.qt4' rcParam.  If matplotlib is version 1.0.1 or older, then
+IPython will always use PyQt4 without setting the v2 APIs, since neither v2
+PyQt nor PySide work.
 
 .. warning::
 
-    Note that this means for ETS 4 to work with PyQt4, ``QT_API`` *must* be set to
-    work with IPython's qt integration, because otherwise PyQt4 will be loaded in
-    an incompatible mode.
+    Note that this means for ETS 4 to work with PyQt4, ``QT_API`` *must* be set
+    to work with IPython's qt integration, because otherwise PyQt4 will be
+    loaded in an incompatible mode.
     
     It also means that you must *not* have ``QT_API`` set if you want to
-    use ``gui=qt`` with code that requires PyQt4 API v1.
-
+    use ``--gui=qt`` with code that requires PyQt4 API v1.
 
 
 .. _matplotlib_support:
@@ -1273,27 +1237,17 b' without setting the v2 APIs, since neither v2 PyQt nor PySide work.'
 Plotting with matplotlib
 ========================
 
+`Matplotlib`_ provides high quality 2D and 3D plotting for Python. Matplotlib
+can produce plots on screen using a variety of GUI toolkits, including Tk,
+PyGTK, PyQt4 and wxPython. It also provides a number of commands useful for
+scientific computing, all with a syntax compatible with that of the popular
+Matlab program.
 
-`Matplotlib`_ provides high quality 2D and
-3D plotting for Python. Matplotlib can produce plots on screen using a variety
-of GUI toolkits, including Tk, PyGTK, PyQt4 and wxPython. It also provides a
-number of commands useful for scientific computing, all with a syntax
-compatible with that of the popular Matlab program.
-
-Many IPython users have come to rely on IPython's ``-pylab`` mode which
-automates the integration of Matplotlib with IPython. We are still in the
-process of working with the Matplotlib developers to finalize the new pylab
-API, but for now you can use Matplotlib interactively using the following
-commands::
-
-    %gui -a wx
-    import matplotlib
-    matplotlib.use('wxagg')
-    from matplotlib import pylab
-    pylab.interactive(True)
-
-All of this will soon be automated as Matplotlib begins to include
-new logic that uses our new GUI support.
+To start IPython with matplotlib support, use the ``--pylab`` switch.  If no
+arguments are given, IPython will automatically detect your choice of
+matplotlib backend.  You can also request a specific backend with
+``--pylab=backend``, where ``backend`` must be one of: 'tk', 'qt', 'wx', 'gtk',
+'osx'.
 
 .. _Matplotlib: http://matplotlib.sourceforge.net
 
@@ -1320,7 +1274,6 b' sections for execution as a demo:'
 .. literalinclude:: ../../examples/lib/example-demo.py
     :language: python
 
-
 In order to run a file as a demo, you must first make a Demo object out
 of it. If the file is named myscript.py, the following code will make a
 demo::
@@ -1353,5 +1306,5 b' Supporting something like this would basically require tracking the'
 internal execution state of the Python interpreter, so only top-level
 divisions are allowed. If you want to be able to open an IPython
 instance at an arbitrary point in a program, you can use IPython's
-embedding facilities, described in detail in Sec. 9
+embedding facilities, see :func:`IPython.embed` for details.
 

docs/source/parallel/parallel_intro.txt

@@ -1,4 +1,4 b''
-.. _ip1par:
+.. _parallel_overview:
 
 ============================
 Overview and getting started
@@ -47,6 +47,16 b' the ``I`` in IPython. The following are some example usage cases for IPython:'
 
 * Run a set of tasks on a set of CPUs using dynamic load balancing.
 
+.. tip::
+
+   At the SciPy 2011 conference in Austin, Min Ragan-Kelley presented a
+   complete 4-hour tutorial on the use of these features, and all the materials
+   for the tutorial are now `available online`__.  That tutorial provides an
+   excellent, hands-on oriented complement to the reference documentation
+   presented here.
+
+.. __: http://minrk.github.com/scipy-tutorial-2011
+
 Architecture overview
 =====================
 

docs/source/parallel/parallel_multiengine.txt

@@ -22,7 +22,7 b' the :command:`ipcluster` command::'
     $ ipcluster start --n=4
     
 For more detailed information about starting the controller and engines, see
-our :ref:`introduction <ip1par>` to using IPython for parallel computing.
+our :ref:`introduction <parallel_overview>` to using IPython for parallel computing.
 
 Creating a ``Client`` instance
 ==============================

docs/source/parallel/parallel_task.txt

@@ -27,7 +27,7 b' the :command:`ipcluster` command::'
 	$ ipcluster start --n=4
 	
 For more detailed information about starting the controller and engines, see
-our :ref:`introduction <ip1par>` to using IPython for parallel computing.
+our :ref:`introduction <parallel_overview>` to using IPython for parallel computing.
 
 Creating a ``Client`` instance
 ==============================

docs/source/whatsnew/version0.11.txt

@@ -1,98 +1,266 b''
-===============
-0.11 Series
-===============
+=============
+ 0.11 Series
+=============
 
 Release 0.11
 ============
 
-IPython 0.11 is a *major* overhaul of IPython, two years in the making.  Most of
-the code base has been rewritten or at least reorganized, breaking backward compatibility
-with several APIs in previous versions.  It is the first major release in two years, and
-probably the most significant change to IPython since its inception.
-As a result of the significant changes, we do plan to have a relatively quick
-succession of releases, as people discover new bugs and regressions.
+IPython 0.11 is a *major* overhaul of IPython, two years in the making.  Most
+of the code base has been rewritten or at least reorganized, breaking backward
+compatibility with several APIs in previous versions.  It is the first major
+release in two years, and probably the most significant change to IPython since
+its inception.  We plan to have a relatively quick succession of releases, as
+people discover new bugs and regressions.  Once we iron out any significant
+bugs in this process and settle down the new APIs, this series will become
+IPython 1.0.  We encourage feedback now on the core APIs, which we hope to
+maintain stable during the 1.0 series.
+
+Since the internal APIs have changed so much, projects using IPython as a
+library (as opposed to end-users of the application) are the most likely to
+encounter regressions or changes that break their existing use patterns.  We
+will make every effort to provide updated versions of the APIs to facilitate
+the transition, and we encourage you to contact us on the `development mailing
+list`__ with questions and feedback.
+
+.. __: http://mail.scipy.org/mailman/listinfo/ipython-dev
+
+Chris Fonnesbeck recently wrote an `excellent post`__ that highlights some of
+our major new features, with examples and screenshots.  We encourage you to
+read it as it provides an illustrated, high-level overview complementing the
+detailed feature breakdown in this document.
+
+.. __: http://stronginference.com/weblog/2011/7/15/innovations-in-ipython.html
+
+A quick summary of the major changes (see below for details):
+
+* **Standalone Qt console**: a new rich console has been added to IPython,
+  started with `ipython qtconsole`.  In this application we have tried to
+  retain the feel of a terminal for fast and efficient workflows, while adding
+  many features that a plain text terminal simply can not support, such as
+  inline figures, full multiline editing with syntax highlighting, tooltips for
+  function calls and much more.  This development was sponsored by `Enthought
+  Inc.`__. See :ref:`below <qtconsole_011>` for details.
+
+.. __: http://enthought.com
+
+* **High-level parallel computing with ZeroMQ**. Using the same architecture
+  that our Qt console is based on, we have completely rewritten our high-level
+  parallel computing machinery that in prior versions used the Twisted
+  networking framework.  While this change will require users to update their
+  codes, the improvements in performance, memory control and internal
+  consistency across our codebase convinced us it was a price worth paying.  We
+  have tried to explain how to best proceed with this update, and will be happy
+  to answer questions that may arise.  A full tutorial describing these
+  features `was presented at SciPy'11`__.
+
+.. __: http://minrk.github.com/scipy-tutorial-2011
+
+* **New model for GUI/plotting support in the terminal**.  Now instead of the
+  various `-Xthread` flags we had before, GUI support is provided without the
+  use of any threads, by directly integrating GUI event loops with Python's
+  `PyOS_InputHook` API.  A new command-line flag `--gui` controls GUI support,
+  and it can also be enabled after IPython startup via the new `%gui` magic.
+  This requires some changes if you want to execute GUI-using scripts inside
+  IPython, see :ref:`the GUI support section <gui_support>` for more details.
+
+* **A two-process architecture.** The Qt console is the first example of using
+  a new model that splits IPython between a kernel process where code is
+  executed and a client that handles user interaction.  We plan on also
+  providing terminal and web-browser based clients using this infrastructure in
+  future releases.  This model allows multiple clients to interact with an
+  IPython process through a well-documented protocol using the ZeroMQ
+  networking library.
+
+* **Refactoring.** the entire codebase has been refactored, in order to make it
+  more modular and easier to contribute to.  IPython has traditionally been a
+  hard project to participate because the old codebase was very monolithic.  We
+  hope this (ongoing) restructuring will make it easier for new developers to
+  join us.
+
+* **Vim integration**. Vim can be configured to seamlessly control an IPython
+  kernel, see the files in :file:`docs/examples/vim` for the full details.
+  This work was done by Paul Ivanov, who prepared a nice `video
+  demonstration`__ of the features it provides.
+
+.. __: http://pirsquared.org/blog/2011/07/28/vim-ipython/
+  
+* **Integration into Microsoft Visual Studio**. Thanks to the work of the
+  Microsoft `Python Tools for Visual Studio`__ team, this version of IPython
+  has been integrated into Microsoft Visual Studio's Python tools open source
+  plug-in.  `Details below`_
+
+.. __: http://pytools.codeplex.com
+.. _details below: ms_visual_studio_011_
+
+* **Improved unicode support**. We closed many bugs related to unicode input.
+
+* **Python 3**. IPython now runs on Python 3.x. See :ref:`python3_011` for
+  details.
+
+* **New profile model**. Profiles are now directories that contain all relevant
+  infromation for that session, and thus better isolate IPython use-cases.
+
+* **SQLite storage for history**. All history is now stored in a SQLite
+  database, providing support for multiple simultaneous sessions that won't
+  clobber each other as well as the ability to perform queries on all stored
+  data.
+
+* **New configuration system**. All parts of IPython are now configured via a
+  mechanism inspired by the Enthought Traits library.  Any configurable element
+  can have its attributes set either via files that now use real Python syntax
+  or from the command-line.
+
+* **Pasting of code with prompts**. IPython now intelligently strips out input
+  prompts , be they plain Python ones (``>>>`` and ``...``) or IPython ones
+  (``In [N]:`` and `` ...:``).  More details :ref:`here <pasting_with_prompts>`.
+  
+
+Authors and support
+-------------------
+
+Over 60 separate authors have contributed to this release, see :ref:`below
+<credits_011>` for a full list.  In particular, we want to highlight the
+extremely active participation of two new core team members: Evan Patterson
+implemented the Qt console, and Thomas Kluyver started with our Python 3 port
+and by now has made major contributions to just about every area of IPython.
+
+We are also grateful for the support we have received during this development
+cycle from several institutions:
+
+- `Enthought Inc`__ funded the development of our new Qt console, an effort that
+  required developing major pieces of underlying infrastructure, which now
+  power not only the Qt console but also our new parallel machinery.  We'd like
+  to thank Eric Jones and Travis Oliphant for their support, as well as Ilan
+  Schnell for his tireless work integrating and testing IPython in the
+  `Enthought Python Distribution`_.
+
+.. __: http://enthought.com
+.. _Enthought Python Distribution: http://www.enthought.com/products/epd.php
+
+- Nipy/NIH: funding via the `NiPy project`__ (NIH grant 5R01MH081909-02) helped
+  us jumpstart the development of this series by restructuring the entire
+  codebase two years ago in a way that would make modular development and
+  testing more approachable.  Without this initial groundwork, all the new
+  features we have added would have been impossible to develop.
+
+.. __: http://nipy.org
+
+- Sage/NSF: funding via the grant `Sage: Unifying Mathematical Software for
+  Scientists, Engineers, and Mathematicians`__ (NSF grant DMS-1015114)
+  supported a meeting in spring 2011 of several of the core IPython developers
+  where major progress was made integrating the last key pieces leading to this
+  release.
+
+.. __: http://modular.math.washington.edu/grants/compmath09
+
+- Microsoft's team working on `Python Tools for Visual Studio`__ developed the 
+  integraton of IPython into the Python plugin for Visual Studio 2010.
+
+.. __: http://pytools.codeplex.com
+
+- Google Summer of Code: in 2010, we had two students developing prototypes of
+  the new machinery that is now maturing in this release: `Omar Zapata`_ and
+  `Gerardo Gutiérrez`_.
 
+.. _Omar Zapata: http://ipythonzmq.blogspot.com/2010/08/ipython-zmq-status.html
+.. _Gerardo Gutiérrez: http://ipythonqt.blogspot.com/2010/04/ipython-qt-interface-gsoc-2010-proposal.html>
 
-Authors
--------
 
-Many users and developers contributed code, features, bug reports and ideas to
-this release.  Please do not hesitate in contacting us if we've failed to
-acknowledge your contribution here.  In particular, for this release we have
-contribution from the following people, a mix of new and regular names (in
-alphabetical order by first name):
+Development summary
+-------------------
 
+In April 2010, after `one breakage too many with bzr`__, we decided to move our
+entire development process to Git and Github.com.  This has proven to be one of
+the best decisions in the project's history, as the combination of git and
+github have made us far, far more productive than we could be with our previous
+tools.  We first converted our bzr repo to a git one without losing history,
+and a few weeks later ported all open Launchpad bugs to github issues with
+their comments mostly intact (modulo some formatting changes).  This ensured a
+smooth transition where no development history or submitted bugs were lost.
 
-* Andy Wilson <wilson.andrew.j+github-at-gmail.com>
-* Aenugu Sai Kiran Reddy <saikrn08-at-gmail.com>
-* Antonio Cuni <antocuni>
-* Barry Wark <barrywark-at-gmail.com>
-* Beetoju Anuradha <anu.beethoju-at-gmail.com>
-* Brad Reisfeld 
-* Brian Granger <ellisonbg-at-gmail.com>
-* Cody Precord 
-* Darren Dale <dsdale24-at-gmail.com>
-* Dav Clark <davclark-at-berkeley.edu>
-* David Warde-Farley <wardefar-at-iro.umontreal.ca>
-* Eric Firing <efiring-at-hawaii.edu>
-* Erik Tollerud <erik.tollerud-at-gmail.com>
-* Evan Patterson <ejpatters-at-gmail.com>
-* Fernando Perez <Fernando.Perez-at-berkeley.edu>
-* Gael Varoquaux <gael.varoquaux-at-normalesup.org>
-* Gerardo <muzgash-at-Muzpelheim>
-* Jason Grout <jason.grout-at-drake.edu>
-* Jens Hedegaard Nielsen <jenshnielsen-at-gmail.com>
-* Justin Riley <justin.t.riley-at-gmail.com>
-* Jörgen Stenarson <jorgen.stenarson-at-bostream.nu>
-* Kiorky 
-* Laurent Dufrechou <laurent.dufrechou-at-gmail.com>
-* Luis Pedro Coelho <luis-at-luispedro.org>
-* Mani chandra <mchandra-at-iitk.ac.in>
-* Mark E. Smith 
-* Mark Voorhies <mark.voorhies-at-ucsf.edu>
-* Martin Spacek <git-at-mspacek.mm.st>
-* Michael Droettboom <mdroe-at-stsci.edu>
-* Min RK <benjaminrk-at-gmail.com>
-* Nick Tarleton <nick-at-quixey.com>
-* Nicolas Rougier <Nicolas.rougier-at-inria.fr>
-* Omar Andres Zapata Mesa <andresete.chaos-at-gmail.com>
-* Paul Ivanov <pivanov314-at-gmail.com>
-* Pauli Virtanen <pauli.virtanen-at-iki.fi>
-* Prabhu Ramachandran 
-* Ramana <sramana9-at-gmail.com>
-* Robert Kern <robert.kern-at-gmail.com>
-* Sathesh Chandra <satheshchandra88-at-gmail.com>
-* Satrajit Ghosh <satra-at-mit.edu>
-* Sebastian Busch 
-* Stefan van der Walt <bzr-at-mentat.za.net>
-* Stephan Peijnik <debian-at-sp.or.at>
-* Steven Bethard 
-* Thomas Kluyver <takowl-at-gmail.com>
-* Thomas Spura <tomspur-at-fedoraproject.org>
-* Tom Fetherston <tfetherston-at-aol.com>
-* Tom MacWright 
-* Ville M. Vainio <vivainio-at-gmail.com>
-* Vishal Vatsa <vishal.vatsa-at-gmail.com>
-* Vishnu S G <sgvishnu777-at-gmail.com>
-* Walter Doerwald <walter-at-livinglogic.de>
-* dan.milstein 
-* muzuiget <muzuiget-at-gmail.com>
-* tzanko 
-* vankayala sowjanya <hai.sowjanya-at-gmail.com>
+.. __: http://mail.scipy.org/pipermail/ipython-dev/2010-April/005944.html
 
-.. note::
+These simple statistics show how much work has been done on the new release, by
+comparing the current code to the last point it had in common with the 0.10
+series.  A huge diff and over 2000 commits make up this development::
 
-    This list was generated with the output of 
-    ``git log dev-0.11 HEAD --format='* %aN <%aE>' | sed 's/@/\-at\-/' | sed 's/<>//' | sort -u``
-    after some cleanup.  If you should be on this list, please add yourself.
+    git diff $(git merge-base 0.10.2 HEAD)  | wc -l
+    287676
+
+    git log $(git merge-base 0.10.2 HEAD) --oneline | wc -l
+    2046
+
+Since our move to github, 510 issues were closed, 225 of which were pull
+requests and 285 regular issues (see :ref:`below <issues_list_011>` for a full
+list).  Github's pull requests are a fantastic mechanism for reviewing code and
+building a shared ownership of the project, and we are making enthusiastic use
+of it.
+
+.. Note::
+
+   This undercounts the number of issues closed in this development cycle,
+   since we only moved to github for issue tracking in May 2010, but we have no
+   way of collecting statistics on the number of issues closed in the old
+   Launchpad bug tracker prior to that.
+
+   
+.. _qtconsole_011:
+
+Qt Console
+----------
+
+IPython now ships with a Qt application that feels very much like a terminal,
+but is in fact a rich GUI that runs an IPython client but supports inline
+figures, saving sessions to PDF and HTML, multiline editing with syntax
+highlighting, graphical calltips and much more:
+
+.. figure:: ../_static/qtconsole.png
+    :width: 400px
+    :alt: IPython Qt console with embedded plots
+    :align: center
+    :target: ../_static/qtconsole.png
+
+    The Qt console for IPython, using inline matplotlib plots.
+
+We hope that many projects will embed this widget, which we've kept
+deliberately very lightweight, into their own environments.  In the future we
+may also offer a slightly more featureful application (with menus and other GUI
+elements), but we remain committed to always shipping this easy to embed
+widget.
+
+See the :ref:`Qt console section <qtconsole>` of the docs for a detailed
+description of the console's features and use.
+
+
+High-level parallel computing with ZeroMQ
+-----------------------------------------
+
+We have completely rewritten the Twisted-based code for high-level parallel
+computing to work atop our new ZeroMQ architecture.  While we realize this will
+break compatibility for a number of users, we hope to make the transition as
+easy as possible with our docs, and we are convinced the change is worth it.
+ZeroMQ provides us with much tighter control over memory, higher performance,
+and its communications are impervious to the Python Global Interpreter Lock
+because they take place in a system-level C++ thread.  The impact of the GIL in
+our previous code was something we could simply not work around, given that
+Twisted is itself a Python library.  So while Twisted is a very capable
+framework, we think ZeroMQ fits our needs much better and we hope you will find
+the change to be a significant improvement in the long run.
+
+Our manual contains :ref:`a full description of how to use IPython for parallel
+computing <parallel_overview>`, and the `tutorial`__ presented by Min
+Ragan-Kelley at the SciPy 2011 conference provides a hands-on complement to the
+reference docs.
+
+.. __: http://minrk.github.com/scipy-tutorial-2011
 
 
 Refactoring
 -----------
 
-As of the 0.11 version of IPython, a signifiant portion of the core has been
-refactored.  This refactoring is founded on a number of new abstractions.
-The main new classes that implement these abstractions are:
+As of this release, a signifiant portion of IPython has been refactored.  This
+refactoring is founded on a number of new abstractions.  The main new classes
+that implement these abstractions are:
 
 * :class:`IPython.utils.traitlets.HasTraits`.
 * :class:`IPython.config.configurable.Configurable`.
@@ -114,8 +282,8 b" a leading '-', nor a space separating key from value. Flags exist, to set"
 multiple values or boolean flags, and these are always prefixed with '--', and
 never take arguments.
 
-ZMQ architecture
-----------------
+ZeroMQ architecture
+-------------------
 
 There is a new GUI framework for IPython, based on a client-server model in
 which multiple clients can communicate with one IPython kernel, using the
@@ -127,6 +295,8 b' The parallel computing framework has also been rewritten using ZMQ. The'
 protocol is described :ref:`here <parallel_messages>`, and the code is in the
 new :mod:`IPython.parallel` module.
 
+.. _python3_011:
+
 Python 3 support
 ----------------
 
@@ -134,20 +304,51 b' A Python 3 version of IPython has been prepared. For the time being, this is'
 maintained separately and updated from the main codebase. Its code can be found
 `here <https://github.com/ipython/ipython-py3k>`_. The parallel computing
 components are not perfect on Python3, but most functionality appears to be
-working.
+working.  As this work is evolving quickly, the best place to find updated
+information about it is our `Python 3 wiki page`__.
+
+.. __: http://wiki.ipython.org/index.php?title=Python_3
+
 
 Unicode
 -------
 
-Entering non-ascii characters in unicode literals (``u"€ø"``) now works properly
-on all platforms. However, entering these in byte/string literals (``"€ø"``)
-will not work as expected on Windows (or any platform where the terminal encoding
-is not UTF-8, as it typically is for Linux & Mac OS X). You can use escape sequences
-(``"\xe9\x82"``) to get bytes above 128, or use unicode literals and encode
-them. This is a limitation of Python 2 which we cannot easily work around.
+Entering non-ascii characters in unicode literals (``u"€ø"``) now works
+properly on all platforms. However, entering these in byte/string literals
+(``"€ø"``) will not work as expected on Windows (or any platform where the
+terminal encoding is not UTF-8, as it typically is for Linux & Mac OS X). You
+can use escape sequences (``"\xe9\x82"``) to get bytes above 128, or use
+unicode literals and encode them. This is a limitation of Python 2 which we
+cannot easily work around.
 
-New features
-------------
+.. _ms_visual_studio_011:
+
+Integration with Microsoft Visual Studio
+----------------------------------------
+
+IPython can be used as the interactive shell in the `Python plugin for
+Microsoft Visual Studio`__, as seen here:
+
+.. figure:: ../_static/ms_visual_studio.png
+    :width: 500px
+    :alt: IPython console embedded in Microsoft Visual Studio.
+    :align: center
+    :target: ../_static/ms_visual_studio.png
+
+    IPython console embedded in Microsoft Visual Studio.
+
+The Microsoft team developing this currently has a release candidate out using
+IPython 0.11. We will continue to collaborate with them to ensure that as they
+approach their final release date, the integration with IPython remains smooth.
+We'd like to thank Dino Viehland and Shahrokh Mortazavi for the work they have
+done towards this feature, as well as Wenming Ye for his support of our WinHPC
+capabilities.
+
+.. __: http://pytools.codeplex.com
+
+
+Additional new features
+-----------------------
 
 * Added ``Bytes`` traitlet, removing ``Str``.  All 'string' traitlets should
   either be ``Unicode`` if a real string, or ``Bytes`` if a C-string. This
@@ -185,10 +386,10 b' New features'
   configuration system :ref:`documentation <config_index>` for more details.
 
 * The :class:`~IPython.core.interactiveshell.InteractiveShell` class is now a
-  :class:`~IPython.config.configurable.Configurable` subclass and has traitlets that
-  determine the defaults and runtime environment. The ``__init__`` method has
-  also been refactored so this class can be instantiated and run without the
-  old :mod:`ipmaker` module.
+  :class:`~IPython.config.configurable.Configurable` subclass and has traitlets
+  that determine the defaults and runtime environment. The ``__init__`` method
+  has also been refactored so this class can be instantiated and run without
+  the old :mod:`ipmaker` module.
 
 * The methods of :class:`~IPython.core.interactiveshell.InteractiveShell` have
   been organized into sections to make it easier to turn more sections
@@ -208,18 +409,15 b' New features'
   strings like ``foo.bar.Bar`` to the actual class.
 
 * Completely refactored the :mod:`IPython.core.prefilter` module into
-  :class:`~IPython.config.configurable.Configurable` subclasses. Added a new layer
-  into the prefilter system, called "transformations" that all new prefilter
-  logic should use (rather than the older "checker/handler" approach).
+  :class:`~IPython.config.configurable.Configurable` subclasses. Added a new
+  layer into the prefilter system, called "transformations" that all new
+  prefilter logic should use (rather than the older "checker/handler"
+  approach).
 
 * Aliases are now components (:mod:`IPython.core.alias`).
 
-* We are now using an internally shipped version of
-  :mod:`~IPython.external.argparse` to parse command line options for
-  :command:`ipython`.
-
 * New top level :func:`~IPython.frontend.terminal.embed.embed` function that can
-  be called to embed IPython at any place in user's code. One the first call it
+  be called to embed IPython at any place in user's code. On the first call it
   will create an :class:`~IPython.frontend.terminal.embed.InteractiveShellEmbed`
   instance and call it. In later calls, it just calls the previously created
   :class:`~IPython.frontend.terminal.embed.InteractiveShellEmbed`.
@@ -263,13 +461,14 b' New features'
 
 * :mod:`IPython.utils.ipstruct` has been refactored to be a subclass of 
   dict.  It also now has full docstrings and doctests.
-* Created a Trait's like implementation in :mod:`IPython.utils.traitlets`.
-  This is a pure Python, lightweight version of a library that is similar to
-  :mod:`enthought.traits`.  We are using this for validation, defaults and
-  notification in our new component system.  Although it is not API compatible
-  with :mod:`enthought.traits`, we plan on moving in this direction so that
-  eventually our implementation could be replaced by a (yet to exist) pure
-  Python version of :mod:`enthought.traits`.
+
+* Created a Traits like implementation in :mod:`IPython.utils.traitlets`.  This
+  is a pure Python, lightweight version of a library that is similar to
+  Enthought's Traits project, but has no dependencies on Enthought's code.  We
+  are using this for validation, defaults and notification in our new component
+  system.  Although it is not 100% API compatible with Enthought's Traits, we
+  plan on moving in this direction so that eventually our implementation could
+  be replaced by a (yet to exist) pure Python version of Enthought Traits.
 
 * Added a new module :mod:`IPython.lib.inputhook` to manage the integration
   with GUI event loops using `PyOS_InputHook`.  See the docstrings in this
@@ -362,10 +561,9 b' Backwards incompatible changes'
 * :mod:`Extensions` has been moved to :mod:`extensions` and all existing
   extensions have been moved to either :mod:`IPython.quarantine` or
   :mod:`IPython.deathrow`. :mod:`IPython.quarantine` contains modules that we
-  plan on keeping but that need to be updated. :mod:`IPython.deathrow`
-  contains modules that are either dead or that should be maintained as third
-  party libraries. More details about this can be found :ref:`here
-  <module_reorg>`.
+  plan on keeping but that need to be updated. :mod:`IPython.deathrow` contains
+  modules that are either dead or that should be maintained as third party
+  libraries. More details about this can be found :ref:`here <module_reorg>`.
 
 * Previous IPython GUIs in :mod:`IPython.frontend` and :mod:`IPython.gui` are
   likely broken, and have been removed to :mod:`IPython.deathrow` because of the
@@ -375,17 +573,184 b' Backwards incompatible changes'
 Known Regressions
 -----------------
 
-We do our best to improve IPython, but there are some known regressions in 0.11 relative
-to 0.10.2.
+We do our best to improve IPython, but there are some known regressions in 0.11
+relative to 0.10.2.  First of all, there are features that have yet to be
+ported to the new APIs, and in order to ensure that all of the installed code
+runs for our users, we have moved them to two separate directories in the
+source distribution, `quarantine` and `deathrow`.  Finally, we have some other
+miscellaneous regressions that we hope to fix as soon as possible.  We now
+describe all of these in more detail.
+
+Quarantine
+~~~~~~~~~~
+
+These are tools and extensions that we consider relatively easy to update to
+the new classes and APIs, but that we simply haven't had time for.  Any user
+who is interested in one of these is encouraged to help us by porting it and
+submitting a pull request on our `development site`_.
+
+.. _development site:: http://github.com/ipython/ipython
+
+Currently, the quarantine directory contains::
+
+    clearcmd.py            ipy_fsops.py            ipy_signals.py
+    envpersist.py          ipy_gnuglobal.py        ipy_synchronize_with.py
+    ext_rescapture.py      ipy_greedycompleter.py  ipy_system_conf.py
+    InterpreterExec.py     ipy_jot.py              ipy_which.py
+    ipy_app_completers.py  ipy_lookfor.py          ipy_winpdb.py
+    ipy_autoreload.py      ipy_profile_doctest.py  ipy_workdir.py
+    ipy_completers.py      ipy_pydb.py             jobctrl.py
+    ipy_editors.py         ipy_rehashdir.py        ledit.py
+    ipy_exportdb.py        ipy_render.py           pspersistence.py
+    ipy_extutil.py         ipy_server.py           win32clip.py
+
+Deathrow
+~~~~~~~~
+
+These packages may be harder to update or make most sense as third-party
+libraries.  Some of them are completely obsolete and have been already replaced
+by better functionality (we simply haven't had the time to carefully weed them
+out so they are kept here for now). Others simply require fixes to code that
+the current core team may not be familiar with.  If a tool you were used to is
+included here, we encourage you to contact the dev list and we can discuss
+whether it makes sense to keep it in IPython (if it can be maintained).
+
+Currently, the deathrow directory contains::
+
+    astyle.py              ipy_defaults.py          ipy_vimserver.py
+    dtutils.py             ipy_kitcfg.py            numeric_formats.py
+    Gnuplot2.py            ipy_legacy.py            numutils.py
+    GnuplotInteractive.py  ipy_p4.py                outputtrap.py
+    GnuplotRuntime.py      ipy_profile_none.py      PhysicalQInput.py
+    ibrowse.py             ipy_profile_numpy.py     PhysicalQInteractive.py
+    igrid.py               ipy_profile_scipy.py     quitter.py*
+    ipipe.py               ipy_profile_sh.py        scitedirector.py
+    iplib.py               ipy_profile_zope.py      Shell.py
+    ipy_constants.py       ipy_traits_completer.py  twshell.py
+
+
+Other regressions
+~~~~~~~~~~~~~~~~~
+
+* The machinery that adds functionality to the 'sh' profile for using IPython
+  as your system shell has not been updated to use the new APIs.  As a result,
+  only the aesthetic (prompt) changes are still implemented. We intend to fix
+  this by 0.12.  Tracked as issue 547_.
+
+.. _547: https://github.com/ipython/ipython/issues/547
+
+* The installation of scripts on Windows was broken without setuptools, so we
+  now depend on setuptools on Windows.  We hope to fix setuptools-less
+  installation, and then remove the setuptools dependency.  Issue 539_.
+
+.. _539: https://github.com/ipython/ipython/issues/539
+
+* The directory history `_dh` is not saved between sessions.  Issue 634_.
+
+.. _634: https://github.com/ipython/ipython/issues/634
+
+
+Removed Features
+----------------
+
+As part of the updating of IPython, we have removed a few features for the
+purpsoes of cleaning up the codebase and interfaces.  These removals are
+permanent, but for any item listed below, equivalent functionality is
+available.
+
+* The magics Exit and Quit have been dropped as ways to exit IPython. Instead,
+  the lowercase forms of both work either as a bare name (``exit``) or a
+  function call (``exit()``).  You can assign these to other names using
+  exec_lines in the config file.
+
+
+.. _credits_011::
+
+Credits
+-------
+
+Many users and developers contributed code, features, bug reports and ideas to
+this release.  Please do not hesitate in contacting us if we've failed to
+acknowledge your contribution here.  In particular, for this release we have
+contribution from the following people, a mix of new and regular names (in
+alphabetical order by first name):
+
+* Aenugu Sai Kiran Reddy <saikrn08-at-gmail.com>
+* andy wilson <wilson.andrew.j+github-at-gmail.com>
+* Antonio Cuni <antocuni>
+* Barry Wark <barrywark-at-gmail.com>
+* Beetoju Anuradha <anu.beethoju-at-gmail.com>
+* Benjamin Ragan-Kelley <minrk-at-Mercury.local>
+* Brad Reisfeld
+* Brian E. Granger <ellisonbg-at-gmail.com>
+* Christoph Gohlke <cgohlke-at-uci.edu>
+* Cody Precord
+* dan.milstein
+* Darren Dale <dsdale24-at-gmail.com>
+* Dav Clark <davclark-at-berkeley.edu>
+* David Warde-Farley <wardefar-at-iro.umontreal.ca>
+* epatters <ejpatters-at-gmail.com>
+* epatters <epatters-at-caltech.edu>
+* epatters <epatters-at-enthought.com>
+* Eric Firing <efiring-at-hawaii.edu>
+* Erik Tollerud <erik.tollerud-at-gmail.com>
+* Evan Patterson <epatters-at-enthought.com>
+* Fernando Perez <Fernando.Perez-at-berkeley.edu>
+* Gael Varoquaux <gael.varoquaux-at-normalesup.org>
+* Gerardo <muzgash-at-Muzpelheim>
+* Jason Grout <jason.grout-at-drake.edu>
+* John Hunter <jdh2358-at-gmail.com>
+* Jens Hedegaard Nielsen <jenshnielsen-at-gmail.com>
+* Johann Cohen-Tanugi <johann.cohentanugi-at-gmail.com>
+* Jörgen Stenarson <jorgen.stenarson-at-bostream.nu>
+* Justin Riley <justin.t.riley-at-gmail.com>
+* Kiorky
+* Laurent Dufrechou <laurent.dufrechou-at-gmail.com>
+* Luis Pedro Coelho <lpc-at-cmu.edu>
+* Mani chandra <mchandra-at-iitk.ac.in>
+* Mark E. Smith
+* Mark Voorhies <mark.voorhies-at-ucsf.edu>
+* Martin Spacek <git-at-mspacek.mm.st>
+* Michael Droettboom <mdroe-at-stsci.edu>
+* MinRK <benjaminrk-at-gmail.com>
+* muzuiget <muzuiget-at-gmail.com>
+* Nick Tarleton <nick-at-quixey.com>
+* Nicolas Rougier <Nicolas.rougier-at-inria.fr>
+* Omar Andres Zapata Mesa <andresete.chaos-at-gmail.com>
+* Paul Ivanov <pivanov314-at-gmail.com>
+* Pauli Virtanen <pauli.virtanen-at-iki.fi>
+* Prabhu Ramachandran
+* Ramana <sramana9-at-gmail.com>
+* Robert Kern <robert.kern-at-gmail.com>
+* Sathesh Chandra <satheshchandra88-at-gmail.com>
+* Satrajit Ghosh <satra-at-mit.edu>
+* Sebastian Busch
+* Skipper Seabold <jsseabold-at-gmail.com>
+* Stefan van der Walt <bzr-at-mentat.za.net>
+* Stephan Peijnik <debian-at-sp.or.at>
+* Steven Bethard
+* Thomas Kluyver <takowl-at-gmail.com>
+* Thomas Spura <tomspur-at-fedoraproject.org>
+* Tom Fetherston <tfetherston-at-aol.com>
+* Tom MacWright
+* tzanko
+* vankayala sowjanya <hai.sowjanya-at-gmail.com>
+* Vivian De Smedt <vds2212-at-VIVIAN>
+* Ville M. Vainio <vivainio-at-gmail.com>
+* Vishal Vatsa <vishal.vatsa-at-gmail.com>
+* Vishnu S G <sgvishnu777-at-gmail.com>
+* Walter Doerwald <walter-at-livinglogic.de>
+
+.. note::
+
+    This list was generated with the output of
+    ``git log dev-0.11 HEAD --format='* %aN <%aE>' | sed 's/@/\-at\-/' | sed 's/<>//' | sort -u``
+    after some cleanup.  If you should be on this list, please add yourself.
+
 
-* The machinery that adds functionality to the 'sh' profile for using IPython as your
-  system shell has not been updated to use the new APIs.  As a result, only the aesthetic
-  (prompt) changes are still implemented. We intend to fix this by 0.12.
+.. _issues_list_011:
 
-* The installation of scripts on Windows was broken without setuptools, so we now
-  depend on setuptools on Windows.  We hope to fix setuptools-less installation,
-  and then remove the setuptools dependency.
+Closed issues
+=============
 
-* Capitalised Exit and Quit have been dropped ways to exit IPython. The lowercase forms
-  of both work either as a bare name (``exit``) or a function call (``exit()``).
-  You can assign these to other names using exec_lines in the config file.
+.. include:: github-stats-011.txt

docs/sphinxext/ipython_directive.py

@@ -3,38 +3,38 b''
 
 This directive allows pasting of entire interactive IPython sessions, prompts
 and all, and their code will actually get re-executed at doc build time, with
-all prompts renumbered sequentially.
+all prompts renumbered sequentially. It also allows you to input code as a pure
+python input by giving the argument python to the directive. The output looks
+like an interactive ipython section.
 
 To enable this directive, simply list it in your Sphinx ``conf.py`` file
 (making sure the directory where you placed it is visible to sphinx, as is
 needed for all Sphinx directives).
 
 By default this directive assumes that your prompts are unchanged IPython ones,
-but this can be customized.  For example, the following code in your Sphinx
-config file will configure this directive for the following input/output
-prompts ``Yade [1]:`` and ``-> [1]:``::
-
- import ipython_directive as id
- id.rgxin =re.compile(r'(?:In |Yade )\[(\d+)\]:\s?(.*)\s*')
- id.rgxout=re.compile(r'(?:Out| ->  )\[(\d+)\]:\s?(.*)\s*')
- id.fmtin ='Yade [%d]:'
- id.fmtout=' ->  [%d]:'
-
- from IPython import Config
- id.CONFIG = Config(
-   prompt_in1="Yade [\#]:",
-   prompt_in2="     .\D..",
-   prompt_out=" ->  [\#]:"
- )
- id.reconfig_shell()
-
- import ipython_console_highlighting as ich
- ich.IPythonConsoleLexer.input_prompt=
-    re.compile("(Yade \[[0-9]+\]: )|(   \.\.\.+:)")
- ich.IPythonConsoleLexer.output_prompt=
-    re.compile("(( ->  )|(Out)\[[0-9]+\]: )|(   \.\.\.+:)")
- ich.IPythonConsoleLexer.continue_prompt=re.compile("   \.\.\.+:")
-
+but this can be customized. The configurable options that can be placed in
+conf.py are
+
+ipython_savefig_dir:
+    The directory in which to save the figures. This is relative to the
+    Sphinx source directory. The default is `html_static_path`.
+ipython_rgxin:
+    The compiled regular expression to denote the start of IPython input
+    lines. The default is re.compile('In \[(\d+)\]:\s?(.*)\s*'). You
+    shouldn't need to change this.
+ipython_rgxout:
+    The compiled regular expression to denote the start of IPython output
+    lines. The default is re.compile('Out\[(\d+)\]:\s?(.*)\s*'). You
+    shouldn't need to change this.
+ipython_promptin:
+    The string to represent the IPython input prompt in the generated ReST.
+    The default is 'In [%d]:'. This expects that the line numbers are used
+    in the prompt.
+ipython_promptout:
+
+    The string to represent the IPython prompt in the generated ReST. The
+    default is 'Out [%d]:'. This expects that the line numbers are used
+    in the prompt.
 
 ToDo
 ----
@@ -42,8 +42,6 b' ToDo'
 - Turn the ad-hoc test() function into a real test suite.
 - Break up ipython-specific functionality from matplotlib stuff into better
   separated code.
-- Make sure %bookmarks used internally are removed on exit.
-
 
 Authors
 -------
@@ -51,6 +49,7 b' Authors'
 - John D Hunter: orignal author.
 - Fernando Perez: refactoring, documentation, cleanups, port to 0.11.
 - VáclavŠmilauer <eudoxos-AT-arcig.cz>: Prompt generalizations.
+- Skipper Seabold, refactoring, cleanups, pure python addition
 """
 
 #-----------------------------------------------------------------------------
@@ -62,6 +61,7 b' import cStringIO'
 import os
 import re
 import sys
+import tempfile
 
 # To keep compatibility with various python versions
 try:
@@ -73,34 +73,26 b' except ImportError:'
 import matplotlib
 import sphinx
 from docutils.parsers.rst import directives
+from docutils import nodes
+from sphinx.util.compat import Directive
 
 matplotlib.use('Agg')
 
 # Our own
 from IPython import Config, InteractiveShell
-from IPython.utils.io import Term
+from IPython.core.profiledir import ProfileDir
+from IPython.utils import io
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
-
-sphinx_version = sphinx.__version__.split(".")
-# The split is necessary for sphinx beta versions where the string is
-# '6b1'
-sphinx_version = tuple([int(re.split('[a-z]', x)[0])
-                        for x in sphinx_version[:2]])
-
+# for tokenizing blocks
 COMMENT, INPUT, OUTPUT =  range(3)
-CONFIG = Config()
-rgxin = re.compile('In \[(\d+)\]:\s?(.*)\s*')
-rgxout = re.compile('Out\[(\d+)\]:\s?(.*)\s*')
-fmtin = 'In [%d]:'
-fmtout = 'Out[%d]:'
 
 #-----------------------------------------------------------------------------
 # Functions and class declarations
 #-----------------------------------------------------------------------------
-def block_parser(part):
+def block_parser(part, rgxin, rgxout, fmtin, fmtout):
     """
     part is a string of ipython text, comprised of at most one
     input, one ouput, comments, and blank lines.  The block parser
@@ -194,20 +186,13 b' def block_parser(part):'
 
     return block
 
-
 class EmbeddedSphinxShell(object):
     """An embedded IPython instance to run inside Sphinx"""
 
     def __init__(self):
 
         self.cout = cStringIO.StringIO()
-        Term.cout = self.cout
-        Term.cerr = self.cout
 
-        # For debugging, so we can see normal output, use this:
-        # from IPython.utils.io import Tee
-        #Term.cout = Tee(self.cout, channel='stdout') # dbg
-        #Term.cerr = Tee(self.cout, channel='stderr') # dbg
 
         # Create config object for IPython
         config = Config()
@@ -219,14 +204,28 b' class EmbeddedSphinxShell(object):'
         config.InteractiveShell.autoindent = False
         config.InteractiveShell.colors = 'NoColor'
 
+        # create a profile so instance history isn't saved
+        tmp_profile_dir = tempfile.mkdtemp(prefix='profile_')
+        profname = 'auto_profile_sphinx_build'
+        pdir = os.path.join(tmp_profile_dir,profname)
+        profile = ProfileDir.create_profile_dir(pdir)
+
         # Create and initialize ipython, but don't start its mainloop
-        IP = InteractiveShell.instance(config=config)
+        IP = InteractiveShell.instance(config=config, profile_dir=profile)
+        # io.stdout redirect must be done *after* instantiating InteractiveShell
+        io.stdout = self.cout
+        io.stderr = self.cout
+
+        # For debugging, so we can see normal output, use this:
+        #from IPython.utils.io import Tee
+        #io.stdout = Tee(self.cout, channel='stdout') # dbg
+        #io.stderr = Tee(self.cout, channel='stderr') # dbg
 
         # Store a few parts of IPython we'll need.
         self.IP = IP
         self.user_ns = self.IP.user_ns
         self.user_global_ns = self.IP.user_global_ns
-                                    
+
         self.input = ''
         self.output = ''
 
@@ -238,27 +237,61 b' class EmbeddedSphinxShell(object):'
         # pyplot as plt so we can make a call to the plt.gcf().savefig
         self._pyplot_imported = False
 
-        # we need bookmark the current dir first so we can save
-        # relative to it
-        self.process_input_line('bookmark ipy_basedir')
+    def clear_cout(self):
         self.cout.seek(0)
         self.cout.truncate(0)
 
-    def process_input_line(self, line):
+    def process_input_line(self, line, store_history=True):
         """process the input, capturing stdout"""
         #print "input='%s'"%self.input
         stdout = sys.stdout
+        splitter = self.IP.input_splitter
         try:
             sys.stdout = self.cout
-            self.IP.push_line(line)
+            splitter.push(line)
+            more = splitter.push_accepts_more()
+            if not more:
+                source_raw = splitter.source_raw_reset()[1]
+                self.IP.run_cell(source_raw, store_history=store_history)
         finally:
             sys.stdout = stdout
 
+    def process_image(self, decorator):
+        """
+        # build out an image directive like
+        # .. image:: somefile.png
+        #    :width 4in
+        #
+        # from an input like
+        # savefig somefile.png width=4in
+        """
+        savefig_dir = self.savefig_dir
+        source_dir = self.source_dir
+        saveargs = decorator.split(' ')
+        filename = saveargs[1]
+        # insert relative path to image file in source
+        outfile = os.path.relpath(os.path.join(savefig_dir,filename),
+                    source_dir)
+
+        imagerows = ['.. image:: %s'%outfile]
+
+        for kwarg in saveargs[2:]:
+            arg, val = kwarg.split('=')
+            arg = arg.strip()
+            val = val.strip()
+            imagerows.append('   :%s: %s'%(arg, val))
+
+        image_file = os.path.basename(outfile) # only return file name
+        image_directive = '\n'.join(imagerows)
+        return image_file, image_directive
+
+
     # Callbacks for each type of token
     def process_input(self, data, input_prompt, lineno):
         """Process data block for INPUT token."""
         decorator, input, rest = data
         image_file = None
+        image_directive = None
         #print 'INPUT:', data  # dbg
         is_verbatim = decorator=='@verbatim' or self.is_verbatim
         is_doctest = decorator=='@doctest' or self.is_doctest
@@ -272,48 +305,31 b' class EmbeddedSphinxShell(object):'
         Nc = len(continuation)
 
         if is_savefig:
-            saveargs = decorator.split(' ')
-            filename = saveargs[1]
-            outfile = os.path.join('_static/%s'%filename)
-            # build out an image directive like
-            # .. image:: somefile.png
-            #    :width 4in
-            #
-            # from an input like
-            # savefig somefile.png width=4in
-            imagerows = ['.. image:: %s'%outfile]
-
-            for kwarg in saveargs[2:]:
-                arg, val = kwarg.split('=')
-                arg = arg.strip()
-                val = val.strip()
-                imagerows.append('   :%s: %s'%(arg, val))
-
-            image_file = outfile
-            image_directive = '\n'.join(imagerows)
-
-        # TODO: can we get "rest" from ipython
-        #self.process_input_line('\n'.join(input_lines))
+            image_file, image_directive = self.process_image(decorator)
 
         ret = []
         is_semicolon = False
+        store_history = True
 
         for i, line in enumerate(input_lines):
             if line.endswith(';'):
                 is_semicolon = True
+            if is_semicolon or is_suppress:
+                store_history = False
 
             if i==0:
                 # process the first input line
                 if is_verbatim:
                     self.process_input_line('')
+                    self.IP.execution_count += 1 # increment it anyway
                 else:
                     # only submit the line in non-verbatim mode
-                    self.process_input_line(line)
+                    self.process_input_line(line, store_history=store_history)
                 formatted_line = '%s %s'%(input_prompt, line)
             else:
                 # process a continuation line
                 if not is_verbatim:
-                    self.process_input_line(line)
+                    self.process_input_line(line, store_history=store_history)
 
                 formatted_line = '%s %s'%(continuation, line)
 
@@ -334,7 +350,8 b' class EmbeddedSphinxShell(object):'
             ret.append(output)
 
         self.cout.truncate(0)
-        return ret, input_lines, output, is_doctest, image_file
+        return (ret, input_lines, output, is_doctest, image_file,
+                    image_directive)
         #print 'OUTPUT', output  # dbg
 
     def process_output(self, data, output_prompt,
@@ -345,16 +362,19 b' class EmbeddedSphinxShell(object):'
             found = output
             if found is not None:
                 found = found.strip()
-                
+
                 # XXX - fperez: in 0.11, 'output' never comes with the prompt
                 # in it, just the actual output text.  So I think all this code
                 # can be nuked...
-                ## ind = found.find(output_prompt)
-                ## if ind<0:
-                ##     e='output prompt="%s" does not match out line=%s' % \
-                ##        (output_prompt, found)
-                ##     raise RuntimeError(e)
-                ## found = found[len(output_prompt):].strip()
+
+                # the above comment does not appear to be accurate... (minrk)
+
+                ind = found.find(output_prompt)
+                if ind<0:
+                    e='output prompt="%s" does not match out line=%s' % \
+                       (output_prompt, found)
+                    raise RuntimeError(e)
+                found = found[len(output_prompt):].strip()
 
                 if found!=submitted:
                     e = ('doctest failure for input_lines="%s" with '
@@ -364,36 +384,45 b' class EmbeddedSphinxShell(object):'
                 #print 'doctest PASSED for input_lines="%s" with found_output="%s" and submitted output="%s"'%(input_lines, found, submitted)
 
     def process_comment(self, data):
-        """Process data block for COMMENT token."""
+        """Process data fPblock for COMMENT token."""
         if not self.is_suppress:
             return [data]
 
+    def save_image(self, image_file):
+        """
+        Saves the image file to disk.
+        """
+        self.ensure_pyplot()
+        command = 'plt.gcf().savefig("%s")'%image_file
+        #print 'SAVEFIG', command  # dbg
+        self.process_input_line('bookmark ipy_thisdir', store_history=False)
+        self.process_input_line('cd -b ipy_savedir', store_history=False)
+        self.process_input_line(command, store_history=False)
+        self.process_input_line('cd -b ipy_thisdir', store_history=False)
+        self.process_input_line('bookmark -d ipy_thisdir', store_history=False)
+        self.clear_cout()
+
+
     def process_block(self, block):
         """
         process block from the block_parser and return a list of processed lines
         """
-
         ret = []
         output = None
         input_lines = None
+        lineno = self.IP.execution_count
 
-        m = rgxin.match(str(self.IP.outputcache.prompt1).strip())
-        lineno = int(m.group(1))
-
-        input_prompt = fmtin%lineno
-        output_prompt = fmtout%lineno
+        input_prompt = self.promptin%lineno
+        output_prompt = self.promptout%lineno
         image_file = None
         image_directive = None
-        # XXX - This needs a second refactor.  There's too much state being
-        # held globally, which makes for a very awkward interface and large,
-        # hard to test functions.  I've already broken this up at least into
-        # three separate processors to isolate the logic better, but this only
-        # serves to highlight the coupling.  Next we need to clean it up...
+
         for token, data in block:
             if token==COMMENT:
                 out_data = self.process_comment(data)
             elif token==INPUT:
-                out_data, input_lines, output, is_doctest, image_file= \
+                (out_data, input_lines, output, is_doctest, image_file,
+                    image_directive) = \
                           self.process_input(data, input_prompt, lineno)
             elif token==OUTPUT:
                 out_data = \
@@ -403,88 +432,235 b' class EmbeddedSphinxShell(object):'
             if out_data:
                 ret.extend(out_data)
 
+        # save the image files
         if image_file is not None:
-            self.ensure_pyplot()
-            command = 'plt.gcf().savefig("%s")'%image_file
-            print 'SAVEFIG', command  # dbg
-            self.process_input_line('bookmark ipy_thisdir')
-            self.process_input_line('cd -b ipy_basedir')
-            self.process_input_line(command)
-            self.process_input_line('cd -b ipy_thisdir')
-            self.cout.seek(0)
-            self.cout.truncate(0)
+            self.save_image(image_file)
+
         return ret, image_directive
 
     def ensure_pyplot(self):
         if self._pyplot_imported:
             return
-        self.process_input_line('import matplotlib.pyplot as plt')
+        self.process_input_line('import matplotlib.pyplot as plt',
+                                store_history=False)
 
-# A global instance used below. XXX: not sure why this can't be created inside
-# ipython_directive itself.
-shell = EmbeddedSphinxShell()
+    def process_pure_python(self, content):
+        """
+        content is a list of strings. it is unedited directive conent
+
+        This runs it line by line in the InteractiveShell, prepends
+        prompts as needed capturing stderr and stdout, then returns
+        the content as a list as if it were ipython code
+        """
+        output = []
+        savefig = False # keep up with this to clear figure
+        multiline = False # to handle line continuation
+        fmtin = self.promptin
+
+        for lineno, line in enumerate(content):
+
+            line_stripped = line.strip()
+
+            if not len(line):
+                output.append(line) # preserve empty lines in output
+                continue
+
+            # handle decorators
+            if line_stripped.startswith('@'):
+                output.extend([line])
+                if 'savefig' in line:
+                    savefig = True # and need to clear figure
+                continue
+
+            # handle comments
+            if line_stripped.startswith('#'):
+                output.extend([line])
+                continue
+
+            # deal with multilines
+            if not multiline: # not currently on a multiline
+
+                if line_stripped.endswith('\\'): # now we are
+                    multiline = True
+                    cont_len = len(str(lineno)) + 2
+                    line_to_process = line.strip('\\')
+                    output.extend([u"%s %s" % (fmtin%lineno,line)])
+                    continue
+                else: # no we're still not
+                    line_to_process = line.strip('\\')
+            else: # we are currently on a multiline
+                line_to_process += line.strip('\\')
+                if line_stripped.endswith('\\'): # and we still are
+                    continuation = '.' * cont_len
+                    output.extend([(u'   %s: '+line_stripped) % continuation])
+                    continue
+                # else go ahead and run this multiline then carry on
+
+            # get output of line
+            self.process_input_line(unicode(line_to_process.strip()),
+                                    store_history=False)
+            out_line = self.cout.getvalue()
+            self.clear_cout()
+
+            # clear current figure if plotted
+            if savefig:
+                self.ensure_pyplot()
+                self.process_input_line('plt.clf()', store_history=False)
+                self.clear_cout()
+                savefig = False
+
+            # line numbers don't actually matter, they're replaced later
+            if not multiline:
+                in_line = u"%s %s" % (fmtin%lineno,line)
+
+                output.extend([in_line])
+            else:
+                output.extend([(u'   %s: '+line_stripped) % continuation])
+                multiline = False
+            if len(out_line):
+                output.extend([out_line])
+            output.extend([u''])
+
+        return output
+
+class IpythonDirective(Directive):
+
+    has_content = True
+    required_arguments = 0
+    optional_arguments = 4 # python, suppress, verbatim, doctest
+    final_argumuent_whitespace = True
+    option_spec = { 'python': directives.unchanged,
+                    'suppress' : directives.flag,
+                    'verbatim' : directives.flag,
+                    'doctest' : directives.flag,
+                  }
 
-def reconfig_shell():
-    """Called after setting module-level variables to re-instantiate
-    with the set values (since shell is instantiated first at import-time
-    when module variables have default values)"""
-    global shell
     shell = EmbeddedSphinxShell()
 
+    def get_config_options(self):
+        # contains sphinx configuration variables
+        config = self.state.document.settings.env.config
+
+        # get config variables to set figure output directory
+        confdir = self.state.document.settings.env.app.confdir
+        savefig_dir = config.ipython_savefig_dir
+        source_dir = os.path.dirname(self.state.document.current_source)
+        if savefig_dir is None:
+            savefig_dir = config.html_static_path
+        if isinstance(savefig_dir, list):
+            savefig_dir = savefig_dir[0] # safe to assume only one path?
+        savefig_dir = os.path.join(confdir, savefig_dir)
+
+        # get regex and prompt stuff
+        rgxin     = config.ipython_rgxin
+        rgxout    = config.ipython_rgxout
+        promptin  = config.ipython_promptin
+        promptout = config.ipython_promptout
+
+        return savefig_dir, source_dir, rgxin, rgxout, promptin, promptout
+
+    def setup(self):
+        # get config values
+        (savefig_dir, source_dir, rgxin,
+                rgxout, promptin, promptout) = self.get_config_options()
+
+        # and attach to shell so we don't have to pass them around
+        self.shell.rgxin = rgxin
+        self.shell.rgxout = rgxout
+        self.shell.promptin = promptin
+        self.shell.promptout = promptout
+        self.shell.savefig_dir = savefig_dir
+        self.shell.source_dir = source_dir
 
-def ipython_directive(name, arguments, options, content, lineno,
-                      content_offset, block_text, state, state_machine,
-                      ):
+        # setup bookmark for saving figures directory
 
-    debug = ipython_directive.DEBUG
-    shell.is_suppress = options.has_key('suppress')
-    shell.is_doctest = options.has_key('doctest')
-    shell.is_verbatim = options.has_key('verbatim')
+        self.shell.process_input_line('bookmark ipy_savedir %s'%savefig_dir,
+                                      store_history=False)
+        self.shell.clear_cout()
 
-    #print 'ipy', shell.is_suppress, options
-    parts = '\n'.join(content).split('\n\n')
-    lines = ['.. sourcecode:: ipython', '']
+        return rgxin, rgxout, promptin, promptout
 
-    figures = []
-    for part in parts:
-        block = block_parser(part)
 
-        if len(block):
-            rows, figure = shell.process_block(block)
-            for row in rows:
-                lines.extend(['    %s'%line for line in row.split('\n')])
+    def teardown(self):
+        # delete last bookmark
+        self.shell.process_input_line('bookmark -d ipy_savedir',
+                                      store_history=False)
+        self.shell.clear_cout()
 
-            if figure is not None:
-                figures.append(figure)
+    def run(self):
+        debug = False
 
-    for figure in figures:
-        lines.append('')
-        lines.extend(figure.split('\n'))
-        lines.append('')
+        #TODO, any reason block_parser can't be a method of embeddable shell
+        # then we wouldn't have to carry these around
+        rgxin, rgxout, promptin, promptout = self.setup()
 
-    #print lines
-    if len(lines)>2:
-        if debug:
-            print '\n'.join(lines)
-        else:
-            #print 'INSERTING %d lines'%len(lines)
-            state_machine.insert_input(
-                lines, state_machine.input_lines.source(0))
+        options = self.options
+        self.shell.is_suppress = 'suppress' in options
+        self.shell.is_doctest = 'doctest' in options
+        self.shell.is_verbatim = 'verbatim' in options
 
-    return []
 
-ipython_directive.DEBUG = False
-ipython_directive.DEBUG = True  # dbg
+        # handle pure python code
+        if 'python' in self.arguments:
+            content = self.content
+            self.content = self.shell.process_pure_python(content)
+
+        parts = '\n'.join(self.content).split('\n\n')
+
+        lines = ['.. code-block:: ipython','']
+        figures = []
+
+        for part in parts:
+
+            block = block_parser(part, rgxin, rgxout, promptin, promptout)
+
+            if len(block):
+                rows, figure = self.shell.process_block(block)
+                for row in rows:
+                    lines.extend(['   %s'%line for line in row.split('\n')])
+
+                if figure is not None:
+                    figures.append(figure)
+
+        #text = '\n'.join(lines)
+        #figs = '\n'.join(figures)
+
+        for figure in figures:
+            lines.append('')
+            lines.extend(figure.split('\n'))
+            lines.append('')
+
+        #print lines
+        if len(lines)>2:
+            if debug:
+                print '\n'.join(lines)
+            else: #NOTE: this raises some errors, what's it for?
+                #print 'INSERTING %d lines'%len(lines)
+                self.state_machine.insert_input(
+                    lines, self.state_machine.input_lines.source(0))
+
+        text = '\n'.join(lines)
+        txtnode = nodes.literal_block(text, text)
+        txtnode['language'] = 'ipython'
+        #imgnode = nodes.image(figs)
+
+        # cleanup
+        self.teardown()
+
+        return []#, imgnode]
 
 # Enable as a proper Sphinx directive
 def setup(app):
     setup.app = app
-    options = {'suppress': directives.flag,
-               'doctest': directives.flag,
-               'verbatim': directives.flag,
-               }
 
-    app.add_directive('ipython', ipython_directive, True, (0, 2, 0), **options)
+    app.add_directive('ipython', IpythonDirective)
+    app.add_config_value('ipython_savefig_dir', None, True)
+    app.add_config_value('ipython_rgxin',
+                         re.compile('In \[(\d+)\]:\s?(.*)\s*'), True)
+    app.add_config_value('ipython_rgxout',
+                         re.compile('Out\[(\d+)\]:\s?(.*)\s*'), True)
+    app.add_config_value('ipython_promptin', 'In [%d]:', True)
+    app.add_config_value('ipython_promptout', 'Out[%d]:', True)
 
 
 # Simple smoke test, needs to be converted to a proper automatic test.
@@ -507,7 +683,7 b" In [3]: im = imread('stinkbug.png')"
 @savefig mystinkbug.png width=4in
 In [4]: imshow(im)
 Out[4]: <matplotlib.image.AxesImage object at 0x39ea850>
-        
+
 """,
         r"""
 
@@ -542,7 +718,7 b' In [133]: import numpy.random'
 In [134]: numpy.random.seed(2358)
 
 @doctest
-In [135]: np.random.rand(10,2)
+In [135]: numpy.random.rand(10,2)
 Out[135]:
 array([[ 0.64524308,  0.59943846],
        [ 0.47102322,  0.8715456 ],
@@ -615,6 +791,8 b' In [153]: grid(True)'
 
         """,
         ]
+    # skip local-file depending first example:
+    examples = examples[1:]
 
     #ipython_directive.DEBUG = True  # dbg
     #options = dict(suppress=True)  # dbg

setup.py

@@ -7,7 +7,7 b' Under Windows, the command sdist is not supported, since IPython'
 requires utilities which are not available under Windows."""
 
 #-----------------------------------------------------------------------------
-#  Copyright (c) 2008-2010, IPython Development Team.
+#  Copyright (c) 2008-2011, IPython Development Team.
 #  Copyright (c) 2001-2007, Fernando Perez <[e-mail]>
 #  Copyright (c) 2001, Janko Hauser <[e-mail]>
 #  Copyright (c) 2001, Nathaniel Gray <[e-mail]>

setupbase.py

@@ -206,6 +206,9 b' def find_data_files():'
     
     # Simple file lists can be made by hand
     manpages  = filter(isfile, glob(pjoin('docs','man','*.1.gz')))
+    if not manpages:
+        # When running from a source tree, the manpages aren't gzipped
+        manpages = filter(isfile, glob(pjoin('docs','man','*.1')))
     igridhelpfiles = filter(isfile,
                             glob(pjoin('IPython','extensions','igrid_help.*')))
 

tools/github_stats.py

@@ -1,17 +1,47 b''
+#!/usr/bin/env python
+"""Simple tools to query github.com and gather stats about issues.
+"""
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+from __future__ import print_function
+
 import json
-from datetime import datetime, timedelta
 import sys
+
+from datetime import datetime, timedelta
 from urllib import urlopen
 
+#-----------------------------------------------------------------------------
+# Functions
+#-----------------------------------------------------------------------------
+
 def get_issues(project="ipython/ipython/", state="open"):
     """Get a list of the issues from the Github API."""
-    f = urlopen("http://github.com/api/v2/json/issues/list/%s%s" % (project, state))
+    f = urlopen("http://github.com/api/v2/json/issues/list/%s%s" % (project,
+                                                                    state))
     return json.load(f)['issues']
 
+
 def _parse_datetime(s):
     """Parse dates in the format returned by the Github API."""
     return datetime.strptime(s.rpartition(" ")[0], "%Y/%m/%d %H:%M:%S")
 
+
+def issues2dict(issues):
+    """Convert a list of issues to a dict, keyed by issue number."""
+    idict = {}
+    for i in issues:
+        idict[i['number']] = i
+    return idict
+
+
+def is_pull_request(issue):
+    """Return True if the given issue is a pull request."""
+    return 'pull_request_url' in issue
+
+
 def issues_closed_since(period=timedelta(days=365), project="ipython/ipython/"):
     """Get all issues closed since a particular point in time. period
 can either be a datetime object, or a timedelta object. In the
@@ -21,11 +51,59 b' latter case, it is used as a time before the present."""'
         period = datetime.now() - period
     return [i for i in allclosed if _parse_datetime(i['closed_at']) > period]
 
+
+def sorted_by_field(issues, field='closed_at', reverse=False):
+    """Return a list of issues sorted by closing date date."""
+    return sorted(issues, key = lambda i:i[field], reverse=reverse)
+
+
+def report(issues, show_urls=False):
+    """Summary report about a list of issues, printing number and title.
+    """
+    # titles may have unicode in them, so we must encode everything below
+    if show_urls:
+        for i in issues:
+            print('* `%d <%s>`_: %s' % (i['number'],
+                                        i['html_url'].encode('utf-8'),
+                                        i['title'].encode('utf-8')))
+    else:
+        for i in issues:
+            print('* %d: %s' % (i['number'], i['title'].encode('utf-8')))
+
+#-----------------------------------------------------------------------------
+# Main script
+#-----------------------------------------------------------------------------
+
 if __name__ == "__main__":
-    # Demo
+    # Whether to add reST urls for all issues in printout.
+    show_urls = True
+
+    # By default, search one month back
     if len(sys.argv) > 1:
         days = int(sys.argv[1])
     else:
-        days = 365
-    n = len(issues_closed_since(timedelta(days=days)))
-    print "%d issues closed in the last %d days." % (n, days)
+        days = 30
+
+    # turn off to play interactively without redownloading, use %run -i
+    if 1:
+        issues = issues_closed_since(timedelta(days=days))
+
+    # For regular reports, it's nice to show them in reverse chronological order
+    issues = sorted_by_field(issues, reverse=True)
+
+    # Break up into pull requests and regular issues
+    pulls = filter(is_pull_request, issues)
+    regular = filter(lambda i: not is_pull_request(i), issues)
+    n_issues, n_pulls, n_regular = map(len, (issues, pulls, regular))
+
+    # Print summary report we can directly include into release notes.
+    print("Github stats for the last  %d days." % days)
+    print("We closed a total of %d issues, %d pull requests and %d regular \n"
+          "issues; this is the full list (generated with the script \n"
+          "`tools/github_stats.py`):" % (n_issues, n_pulls, n_regular))
+    print()
+    print('Pull requests (%d):\n' % n_pulls)
+    report(pulls, show_urls)
+    print()
+    print('Regular issues (%d):\n' % n_regular)
+    report(regular, show_urls)