IPython Changelog

What's new in IPython 8.24.0

Apr 26, 2024

The biggest change is the move of the matplotlib backend handling from IPython to matplotlib. PR #14371PR #14403.
We will note:
pytest 8 compatibility PR #14413
typing-extension now needs 4.6 or newer. It was already the case, but not explicated. PR #14380
Attempt to speed running code under debugger in some cases. PR #14386 PR #14418.
Multiple fixes to documentation for ipyparallel, simple_prompt and emacs PR #14384 PR #14404 PR #14407
Maintenance and cleanup of debugger PR #14387 PR #14393

New in IPython 8.23.0 (Mar 31, 2024)

New in IPython 8.22.2 (Mar 4, 2024)

New in IPython 8.22.0 (Feb 22, 2024)

New in IPython 8.21.0 (Jan 31, 2024)

New in IPython 8.20.0 (Jan 9, 2024)

New in IPython 8.18.1 (Nov 27, 2023)

New in IPython 8.18.0 (Nov 24, 2023)

New in IPython 8.17.1 (Oct 31, 2023)

New in IPython 8.16.0 (Sep 29, 2023)

New in IPython 8.15.0 (Sep 1, 2023)

New in IPython 8.13.0 (Apr 28, 2023)

New in IPython 8.12.0 (Mar 30, 2023)

New in IPython 8.11.0 (Feb 28, 2023)

New in IPython 8.10.0 (Feb 10, 2023)

New in IPython 8.9.0 (Jan 27, 2023)

New in IPython 8.8.0 (Jan 3, 2023)

New in IPython 8.7.0 (Nov 28, 2022)

New in IPython 8.3.0 (Apr 30, 2022)

New in IPython 7.31.0 (Jan 5, 2022)

New in IPython 8.0.0b1 Pre-release (Jan 4, 2022)

New in IPython 7.29.0 (Oct 30, 2021)

New in IPython 7.28.0 (Sep 25, 2021)

New in IPython 7.26.0 (Aug 1, 2021)

New in IPython 7.25.0 (Jun 25, 2021)

New in IPython 7.24.0 (May 28, 2021)

New in IPython 7.23.1 (May 5, 2021)

New in IPython 7.23.0 (May 4, 2021)

New in IPython 7.22.0 (Mar 28, 2021)

New in IPython 7.21.0 (Feb 27, 2021)

New in IPython 7.20.0 (Feb 1, 2021)

New in IPython 7.19.0 (Feb 1, 2021)

New in IPython 7.9.0 (Oct 25, 2019)

New in IPython 7.8.0 (Sep 2, 2019)

New in IPython 7.7.0 (Jul 28, 2019)

New in IPython 7.5.0 (Apr 25, 2019)

New in IPython 7.4.0 (Mar 22, 2019)

New in IPython 7.3.0 (Feb 19, 2019)

New in IPython 7.2.0 (Dec 1, 2018)

New in IPython 7.1.1 (Nov 7, 2018)

New Core Dev:
We welcome Jonathan Slenders to the commiters. Jonathan has done a fantastic work on Prompt toolkit, and we’d like to recognise his impact by giving him commit rights. #11397
Notables Changes
Major update of “latex to unicode” tab completion map (see below)
Notable New Features:
Restore functionality and documentation of the sphinx directive, which is now stricter (fail on error by default), gained configuration options, have a brand new documentation page IPython Sphinx Directive, which need some cleanup. It is also now tested so we hope to have less regressions. PR #11402
IPython.display.Video now supports width and height arguments, allowing a custom width and height to be set instead of using the video’s width and height. PR #11353
Warn when using HTML('<iframe>') instead of IFrame PR #11350
Allow Dynamic switching of editing mode between vi/emacs and show normal/input mode in prompt when using vi. PR #11390. Use %config TerminalInteractiveShell.editing_mode = 'vi' or %config TerminalInteractiveShell.editing_mode = 'emacs' to dynamically spwitch
Notable Fixes:
Fix entering of multi-line block in terminal IPython, and various crashes in the new input transformation machinery PR #11354, PR #11356, PR #11358, these ones also fix a Compatibility but with Python 3.7.1.
Fix moving through generator stack in ipdb PR #11266
Magics arguments now support quoting. PR #11330
Re-add rprint and rprinte aliases. PR #11331
Remove implicit dependency to ipython_genutils PR #11317
Make nonlocal raise SyntaxError instead of silently failing in async mode. PR #11382
Fix mishandling of magics and = ! assignment just after a dedent in nested code blocks PR #11418
Fix instructions for custom shortcuts PR #11426
Notable Internals improvements:
Use of os.scandir (Python 3 only) to speedup some file system operations. PR #11365
Use perf_counter instead of clock for more precise timing result with %time PR #11376
Many thanks to all the contributors and in particular to bartskowron, and tonyfast who handled a pretty complicated bugs in the input machinery. We had a number of first time contributors and maybe hacktoberfest participant that made significant contributions, and helped us free some time to focus on more complicated bugs.
You can see all the closed issues and Merged PR, new features and fixes here.
Unicode Completion update
In IPython 7.1 the Unicode completion map has been updated and synchronized with the Julia language.
Added and removed character characters:
jmath (ȷ), \underleftrightarrow (U+034D, combining) have been added, while \textasciicaron have been removed
Some sequence have seen their prefix removed:
6 characters text...<tab> should now be inputed with ...<tab> directly,
45 characters Elz...<tab> should now be inputed with ...<tab> directly,
65 characters B...<tab> should now be inputed with ...<tab> directly,
450 characters m...<tab> should now be inputed with ...<tab> directly,
Some sequence have seen their prefix shortened:
5 characters mitBbb...<tab> should now be inputed with bbi...<tab> directly,
52 characters mit...<tab> should now be inputed with i...<tab> directly,
216 characters mbfit...<tab> should now be inputed with bi...<tab> directly,
222 characters mbf...<tab> should now be inputed with b...<tab> directly,
A couple of character had their sequence simplified:
ð, type dh<tab>, instead of eth<tab>
ħ, type hbar<tab>, instead of Elzxh<tab>
ɸ, type ltphi<tab>, instead of textphi<tab>
ϴ, type varTheta<tab>, instead of textTheta<tab>
ℇ, type eulermascheroni<tab>, instead of Eulerconst<tab>
ℎ, type planck<tab>, instead of Planckconst<tab>
U+0336 (COMBINING LONG STROKE OVERLAY), type strike<tab>, instead of Elzbar<tab>.
A couple of sequences have been updated:
varepsilon now give ɛ (GREEK SMALL LETTER EPSILON) instead of ε (GREEK LUNATE EPSILON SYMBOL),
underbar now give U+0331 (COMBINING MACRON BELOW) instead of U+0332 (COMBINING LOW LINE).
IPython 7.0.0
Released Thursday September 27th, 2018
IPython 7 include major features improvement as you can read in the following changelog. This is also the second major version of IPython to support only Python 3 – starting at Python 3.4. Python 2 is still community supported on the bugfix only 5.x branch, but we remind you that Python 2 “end of life” is on Jan 1st 2020.
We were able to backport bug fixes to the 5.x branch thanks to our backport bot which backported more than 70 Pull-Requests, but there are still many PRs that required manually work, and this is an area of the project were you can easily contribute by looking for PRs still needed backport
IPython 6.x branch will likely not see any further release unless critical bugs are found.
Make sure you have pip > 9.0 before upgrading. You should be able to update by simply running
Pip install ipython --upgrade
Or if you have conda installed:
Conda install ipython
Prompt Toolkit 2.0
IPython 7.0+ now uses prompt_toolkit 2.0, if you still need to use earlier prompt_toolkit version you may need to pin IPython to <7.0.
Autowait: Asynchronous REPL
Staring with IPython 7.0 and on Python 3.6+, IPython can automatically await code at top level, you should not need to access an event loop or runner yourself. To know more read the Asynchronous in REPL: Autoawait section of our docs, see PR #11265 or try the following code:
Python 3.6.0
Type 'copyright', 'credits' or 'license' for more information
IPython 7.0.0 -- An enhanced Interactive Python. Type '?' for help.
In [1]: import aiohttp
...: result = aiohttp.get('https://api.github.com')
In [2]: response = await result
<pause for a few 100s ms>
In [3]: await response.json()
Out[3]:
{'authorizations_url': 'https://api.github.com/authorizations',
'code_search_url': 'https://api.github.com/search/code?q={query}{&page,per_page,sort,order}',
...
Note
Async integration is experimental code, behavior may change or be removed between Python and IPython versions without warnings.
Integration is by default with asyncio, but other libraries can be configured, like curio or trio, to improve concurrency in the REPL:
In [1]: %autoawait trio
In [2]: import trio
In [3]: async def child(i):
...: print(" child %s goes to sleep"%i)
...: await trio.sleep(2)
...: print(" child %s wakes up"%i)
In [4]: print('parent start')
...: async with trio.open_nursery() as n:
...: for i in range(3):
...: n.spawn(child, i)
...: print('parent end')
Parent start
child 2 goes to sleep
child 0 goes to sleep
child 1 goes to sleep
<about 2 seconds pause>
child 2 wakes up
child 1 wakes up
child 0 wakes up
Parent end
See Asynchronous in REPL: Autoawait for more information.
Asynchronous code in a Notebook interface or any other frontend using the Jupyter Protocol will need further updates of the IPykernel package.
Non-Asynchronous code
As the internal API of IPython is now asynchronous, IPython needs to run under an event loop. In order to allow many workflows, (like using the %run magic, or copy_pasting code that explicitly starts/stop event loop), when top-level code is detected as not being asynchronous, IPython code is advanced via a pseudo-synchronous runner, and may not advance pending tasks.
Change to Nested Embed
The introduction of the ability to run async code had some effect on the IPython.embed() API. By default embed will not allow you to run asynchronous code unless a event loop is specified.
Effects on Magics
Some magics will not work with Async, and will need updates. Contribution welcome.
Expected Future changes
We expect more internal but public IPython function to become async, and will likely end up having a persisting event loop while IPython is running.
Thanks
This took more than a year in the making, and the code was rebased a number of time leading to commit authorship that may have been lost in the final Pull-Request. Huge thanks to many people for contribution, discussion, code, documentation, use-case: dalejung, danielballan, ellisonbg, fperez, gnestor, minrk, njsmith, pganssle, tacaswell, takluyver , vidartf … And many others.
Autoreload Improvement
The magic %autoreload 2 now captures new methods added to classes. Earlier, only methods existing as of the initial import were being tracked and updated.
This new feature helps dual environment development - Jupyter+IDE - where the code gradually moves from notebook cells to package files, as it gets structured.
Example: An instance of the class MyClass will be able to access the method cube() after it is uncommented and the file file1.py saved on disk.
# notebook
From mymodule import MyClass
First = MyClass(5)
# mymodule/file1.py
Class MyClass:
def __init__(self, a=10):
self.a = a
def square(self):
print('compute square')
return self.a*self.a
# def cube(self):
# print('compute cube')
# return self.a*self.a*self.a
Misc
The autoindent feature that was deprecated in 5.x was re-enabled and un-deprecated in PR #11257
Make %run -n -i ... work correctly. Earlier, if %run was passed both arguments, -n would be silently ignored. See PR #10308
The %%script (as well as %%bash, %%ruby… ) cell magics now raise by default if the return code of the given code is non-zero (thus halting execution of further cells in a notebook). The behavior can be disable by passing the --no-raise-error flag.
Deprecations
A couple of unused function and methods have been deprecated and will be removed in future versions:
IPython.utils.io.raw_print_err
IPython.utils.io.raw_print
Backwards incompatible changes
The API for transforming input before it is parsed as Python code has been completely redesigned, and any custom input transformations will need to be rewritten. See Custom input transformation for details of the new API.

New in IPython 6.2.1 (Nov 6, 2017)

New in IPython 6.0.0 (Apr 25, 2017)

Python 6 feature a major improvement in the completion machinery which is now capable of completing non-executed code. It is also the first version of IPython to stop compatibility with Python 2, which is still supported on the bugfix only 5.x branch. Read below to have a non-exhaustive list of new features:
New completion API and Interface:
The completer Completion API has seen an overhaul, and the new completer have plenty of improvement both from the end users of terminal IPython or for consumers of the API.
This new API is capable of pulling completions from jedi, thus allowing type inference on non-executed code. If jedi is installed completion like the following are now becoming possible without code evaluation.
That is to say, IPython is now capable of inferring that data[0] is a string, and will suggest completions like .capitalize. The completion power of IPython will increase with new Jedi releases, and a number of bugs and more completions are already available on the development version of jedi if you are curious.
The appearance of the completer is controlled by the c.TerminalInteractiveShell.display_completions option that will show the type differently depending on the value among 'column', 'multicolumn' and 'readlinelike'
The use of Jedi also fulfills a number of requests and fix a number of bugs like case-insensitive completion, completion after division operator: See PR #10182.
Extra patches and updates will be needed to the ipykernel package for this feature to be available to other clients like Jupyter Notebook, Lab, Nteract, Hydrogen...
The use of Jedi is should be barely noticeable on recent enough machines, but can be slower on older ones. To tweak the performances, the amount of time given to Jedi to compute type inference can be adjusted with c.IPCompleter.jedi_compute_type_timeout. The objects whose type were not inferred will be shown as <unknown>. Jedi can also be completely deactivated by using the c.Completer.use_jedi=False option.
The old Completer.complete() API is waiting deprecation and should be replaced replaced by Completer.completions() in a near future. Feedback on the current state of the API and suggestions welcome.
Python 3 only codebase:
One of the large challenges in IPython 6.0 has been the adoption of a pure Python 3 codebase, which leads us to great length to upstream patches in pip, pypi and warehouse to make sure Python 2 system still upgrade to the latest compatible Python version compatible.
We remind our Python 2 users that IPython 5 is still compatible with Python 2.7, still maintained and get regular releases. Using pip 9+, upgrading IPython will automatically upgrade to the latest version compatible with your system.
The ability to use only Python 3 on the code base of IPython brings a number of advantage. Most of the newly written code make use of optional function type annotation leading to clearer code and better documentation.
The total size of the repository has also decreased by about 1500 lines (for the first time excluding the big split for 4.0). The decrease is potentially a bit more for the sour as some documents like this one are append only and are about 300 lines long.
The removal as of Python2/Python3 shim layer has made the code quite clearer and more idiomatic in a number of location, and much friendlier to work with and understand. We hope to further embrace Python 3 capability in the next release cycle and introduce more of the Python 3 only idioms (yield from, kwarg only, general unpacking) in the code base of IPython, and see if we can take advantage of these as well to improve user experience with better error messages and hints.
Configurable TerminalInteractiveShell, readline interface:
IPython gained a new c.TerminalIPythonApp.interactive_shell_class option that allows customizing the class used to start the terminal frontend. This should allow a user to use custom interfaces, like reviving the former readline interface which is now a separate package not actively maintained by the core team. See the project to bring back the readline interface: rlipython.
This change will be backported to the IPython 5.x series.
Miscs improvements:
The %%capture magic can now capture the result of a cell (from an expression on the last line), as well as printed and displayed output. PR #9851.
Pressing Ctrl-Z in the terminal debugger now suspends IPython, as it already does in the main terminal prompt.
Autoreload can now reload Enum. See #10232 and PR #10316
IPython.display has gained a GeoJSON object. PR #10288 and PR #10253
Functions Deprecated in 6.x Development cycle:
Loading extensions from ipython_extension_dir prints a warning that this location is pending deprecation. This should only affect users still having extensions installed with %install_ext which has been deprecated since IPython 4.0, and removed in 5.0. Extensions still present in ipython_extension_dir may shadow more recently installed versions using pip. It is thus recommended to clean ipython_extension_dir of any extension now available as a package.
IPython.utils.warn was deprecated in IPython 4.0, and has now been removed. instead of IPython.utils.warn inbuilt warnings module is used.
The function IPython.core.oinspect.py:call_tip is unused, was marked as deprecated (raising a DeprecationWarning) and marked for later removal. PR #10104

New in IPython 5.1.0 (Sep 1, 2016)

New in IPython 3.0.0 (Feb 28, 2015)

New in IPython 2.4.0 (Feb 6, 2015)

New in IPython 2.3.0 (Oct 2, 2014)

New in IPython 2.2.0 (Aug 7, 2014)

New in IPython 2.1.0 (Aug 7, 2014)

Pull Requests:
PR #5871: specify encoding in msgpack.unpackb
PR #5869: Catch more errors from clipboard access on Windows
PR #5866: Make test robust against differences in line endings
PR #5605: Two cell toolbar fixes.
PR #5843: remove Firefox-specific CSS workaround
PR #5845: Pass Windows interrupt event to kernels as an environment variable
PR #5835: fix typo in v2 convert
PR #5841: Fix writing history with output to a file in Python 2
PR #5842: fix typo in nbconvert help
PR #5846: Fix typos in Cython example
PR #5839: Close graphics dev in finally clause
PR #5837: pass on install docs
PR #5832: Fixed example to work with python3
PR #5826: allow notebook tour instantiation to fail
PR #5560: Minor expansion of Cython example
PR #5818: interpret any exception in getcallargs as not callable
PR #5816: Add output to IPython directive when in verbatim mode.
PR #5822: Don’t overwrite widget description in interact
PR #5782: Silence exception thrown by completer when dir() does not return a list
PR #5807: Drop log level to info for Qt console shutdown
PR #5814: Remove -i options from mv, rm and cp aliases
PR #5812: Fix application name when printing subcommand help.
PR #5804: remove an inappropriate !
PR #5805: fix engine startup files
PR #5806: Don’t auto-move .config/ipython if symbolic link
PR #5716: Add booktabs package to latex base.tplx
PR #5669: allows threadsafe sys.stdout.flush from background threads
PR #5668: allow async output on the most recent request
PR #5768: fix cursor keys in long lines wrapped in markdown
PR #5788: run cells with silent=True in %run nb.ipynb
PR #5715: log all failed ajax API requests
PR #5769: Don’t urlescape the text that goes into a title tag
PR #5762: Fix check for pickling closures
PR #5766: View.map with empty sequence should return empty list
PR #5758: Applied bug fix: using fc and ec did not properly set the figure canvas ...
PR #5754: Format command name into subcommand_description at run time, not import
PR #5744: Describe using PyPI/pip to distribute & install extensions
PR #5712: monkeypatch inspect.findsource only when we use it
PR #5708: create checkpoints dir in notebook subdirectories
PR #5714: log error message when API requests fail
PR #5732: Quick typo fix in nbformat/convert.py
PR #5713: Fix a NameError in IPython.parallel
PR #5704: Update nbconvertapp.py
PR #5534: cleanup some pre css inheritance
PR #5699: don’t use common names in require decorators
PR #5692: Update notebook.rst fixing broken reference to notebook examples readme
PR #5693: Update parallel_intro.rst to fix a broken link to examples
PR #5486: disambiguate to location when no IPs can be determined
PR #5574: Remove the outdated keyboard shortcuts from notebook docs
PR #5568: Use __qualname__ in pretty reprs for Python 3
PR #5678: Fix copy & paste error in docstring of ImageWidget class
PR #5677: Fix %bookmark -l for Python 3
PR #5670: nbconvert: Fix CWD imports
PR #5647: Mention git hooks in install documentation
PR #5671: Fix blank slides issue in Reveal slideshow pdf export
PR #5657: use ‘localhost’ as default for the notebook server
PR #5584: more semantic icons
PR #5594: update components with marked-0.3.2
PR #5500: check for Python 3.2
PR #5582: reset readline after running PYTHONSTARTUP
PR #5630: Fixed Issue #4012 Added Help menubar link to Github markdown doc
PR #5613: Fixing bug #5607
PR #5633: Provide more help if lessc is not found.
PR #5620: fixed a typo in IPython.core.formatters
PR #5619: Fix typo in storemagic module docstring
PR #5592: add missing browser to notebook_aliases list
PR #5506: Fix ipconfig regex pattern
PR #5581: Fix rmagic for cells ending in comment.
PR #5576: only process cr if it’s found
PR #5478: Add git-hooks install script. Update README.md
PR #5546: do not shutdown notebook if ‘n’ is part of answer
PR #5527: Don’t remove upload items from nav tree unless explicitly requested.
PR #5501: remove inappropriate wheel tag override
PR #5548: FileNotebookManager: Use shutil.move() instead of os.rename()
PR #5524: never use for (var i in array)
PR #5459: Fix interact animation page jump FF
PR #5559: Minor typo fix in “Cython Magics.ipynb”
PR #5507: Fix typo in interactive widgets examples index notebook
PR #5554: Make HasTraits pickleable
PR #5535: fix n^2 performance issue in coalesce_streams preprocessor
PR #5522: fix iteration over Client
PR #5488: Added missing require and jquery from cdn.
PR #5516: ENH: list generated config files in generated, and rm them upon clean
PR #5493: made a minor fix to one of the widget examples
PR #5512: Update tooltips to refer to shift-tab
PR #5505: Make backport_pr work on Python 3
PR #5503: check explicitly for ‘dev’ before adding the note to docs
PR #5498: use milestones to indicate backport
PR #5492: Polish whatsnew docs
PR #5495: Fix various broken things in docs
PR #5496: Exclude whatsnew/pr directory from docs builds
PR #5489: Fix required Python versions
Issues (37):
5364: Horizontal scrollbar hides cell’s last line on Firefox
5192: horisontal scrollbar overlaps output or touches next cell
5840: Third-party Windows kernels don’t get interrupt signal
2412: print history to file using qtconsole and notebook
5703: Notebook doesn’t render with “ask me every time” cookie setting in Firefox
5817: calling mock object in IPython 2.0.0 under Python 3.4.0 raises AttributeError
5499: Error running widgets nbconvert example
5654: Broken links from ipython documentation
5019: print in QT event callback doesn’t show up in ipython notebook.
5800: Only last In prompt number set ?
5801: startup_command specified in ipengine_config.py is not executed
5690: ipython 2.0.0 and pandoc 1.12.2.1 problem
5408: Add checking/flushing of background output from kernel in mainloop
5407: clearing message handlers on status=idle loses async output
5467: Incorrect behavior of up/down keyboard arrows in code cells on wrapped lines
3085: nicer notebook error message when lacking permissions
5765: map_sync over empty list raises IndexError
5553: Notebook matplotlib inline backend: can’t set figure facecolor
5710: inspect.findsource monkeypatch raises wrong exception for C extensions
5706: Multi-Directory notebooks overwrite each other’s checkpoints
5698: can’t require a function named f
5569: Keyboard shortcuts in documentation are out of date
5566: Function name printing should use __qualname__ instead of __name__ (Python 3)
5676: “bookmark -l” not working in ipython 2.0
5555: Differentiate more clearly between Notebooks and Folders in new UI
5590: Marked double escape
5514: import tab-complete fail with ipython 2.0 shell
4012: Notebook: link to markdown formatting reference
5611: Typo in ‘storemagic’ documentation
5589: Kernel start fails when using –browser argument
5491: Bug in Windows ipconfig ip address regular expression
5579: rmagic extension throws ‘Error while parsing the string.’ when last line is comment
5518: Ipython2 will not open ipynb in example directory
5561: New widget documentation has missing notebook link
5128: Page jumping when output from widget interaction replaced
5519: IPython.parallel.Client behavior as iterator
5510: Tab-completion for function argument list

New in IPython 2.0.0 (Aug 7, 2014)

New in IPython 1.2.1 (Mar 10, 2014)

New in IPython 1.0 (Nov 6, 2013)

Reorganization:
There have been two major reorganizations in IPython 1.0
Added IPython.kernel for all kernel-related code. This means that IPython.zmq has been removed, and much of it is now in IPython.kernel.zmq, some of it being in the top-level IPython.kernel
We have removed the frontend subpackage, as it caused unnecessary depth. So what was IPython.frontend.qt is now IPython.qt, and so on. The one difference is that the notebook has been further flattened, so that IPython.frontend.html.notebook is now just IPython.html. There is a shim module, so IPython.frontend is still importable in 1.0, but there will be a warning
The IPython sphinx directives are now installed in IPython.sphinx, so they can be imported by other projects
Public APIs:
For the first time since 0.10 (sorry, everyone), there is an official public API for starting IPython
from IPython import start_ipython
start_ipython()
This is what packages should use that start their own IPython session, but don’t actually want embedded IPython (most cases). IPython.embed() is used for embedding IPython into the calling namespace, similar to calling Pdb.set_trace(), whereas start_ipython() will start a plain IPython session, loading config and startup files as normal
We also have added
from IPython import get_ipython
Which is a library function for getting the current IPython instance, and will return None if no IPython instance is running. This is the official way to check whether your code is called from inside an IPython session. If you want to check for IPython without unnecessarily importing IPython, use this function
def get_ipython()
"""return IPython instance if there is one, None otherwise"""
import sys
if "IPython" in sys.modules
import IPython
return IPython.get_ipython()
Core:
The input transformation framework has been reworked. This fixes some corner cases, and adds more flexibility for projects which use IPython, like SymPy & SAGE. For more details, see Custom input transformation
Exception types can now be displayed with a custom traceback, by defining a _render_traceback_() method which returns a list of strings, each containing one line of the traceback
A new command, ipython history trim can be used to delete everything but the last 1000 entries in the history database
file__ is defined in both config files at load time, and .ipy files executed with %run
logstart and %logappend are no longer broken
Add glob expansion for %run, e.g. %run -g script.py *.txt
Expand variables ($foo) in Cell Magic argument line
By default, iptest will exclude various slow tests. All tests can be run with iptest –all
SQLite history can be disabled in the various cases that it does not behave well
edit works on interactively defined variables
editor hooks have been restored from quarantine, enabling TextMate as editor, etc
The env variable PYTHONSTARTUP is respected by IPython
The %matplotlib magic was added, which is like the old %pylab magic, but it does not import anything to the interactive namespace. It is recommended that users switch to %matplotlib and explicit imports
The --matplotlib command line flag was also added. It invokes the new %matplotlib magic and can be used in the same way as the old --pylab flag. You can either use it by itself as a flag (--matplotlib), or you can also pass a backend explicitly (--matplotlib qt or --matplotlib=wx, etc)
Backwards incompatible changes¶
Calling InteractiveShell.prefilter() will no longer perform static transformations - the processing of escaped commands such as %magic and !system, and stripping input prompts from code blocks. This functionality was duplicated in IPython.core.inputsplitter, and the latter version was already what IPython relied on. A new API to transform input will be ready before release
Functions from IPython.lib.inputhook to control integration with GUI event loops are no longer exposed in the top level of IPython.lib. Code calling these should make sure to import them from IPython.lib.inputhook
For all kernel managers, the sub_channel attribute has been renamed to iopub_channel
Users on Python versions before 2.6.6, 2.7.1 or 3.2 will now need to call IPython.utils.doctestreload.doctest_reload() to make doctests run correctly inside IPython. Python releases since those versions are unaffected. For details, see PR #3068 and Python issue 8048
The InteractiveShell.cache_main_mod() method has been removed, and new_main_mod() has a different signature, expecting a filename where earlier versions expected a namespace. See PR #3555 for details
The short-lived plugin system has been removed. Extensions are the way to go
NbConvert:
The major milestone for IPython 1.0 is the addition of IPython.nbconvert - tools for converting IPython notebooks to various other formats
Warning
nbconvert is a-level preview code in 1.0
To use nbconvert to convert various file formats
ipython nbconvert --to html *.ipynbSee ipython nbconvert --help for more information. nbconvert depends on pandoc for many of the translations to and from various formats
See also
Converting notebooks to other formats
Notebook:
Major changes to the IPython Notebook in 1.0
The notebook is now autosaved, by default at an interval of two minutes. When you press ‘save’ or Ctrl-S, a checkpoint is made, in a hidden folder. This checkpoint can be restored, so that the autosave model is strictly safer than traditional save. If you change nothing about your save habits, you will always have a checkpoint that you have written, and an autosaved file that is kept up to date
The notebook supports raw_input() / input(), and thus also �bug, and many other Python calls that expect user input
You can load custom javascript and CSS in the notebook by editing the files $(ipython locate profile)/static/custom/custom.js,css
Add %%html, %%svg, %%javascript, and %%latex cell magics for writing raw output in notebook cells
add a redirect handler and anchors on heading cells, so you can link across notebooks, directly to heading cells in other notebooks
Images support width and height metadata, and thereby 2x scaling (retina support)
repr_foo_ methods can return a tuple of (data, metadata), where metadata is a dict containing metadata about the displayed object. This is used to set size, etc. for retina graphics. To enable retina matplotlib figures, simply set InlineBackend.figure_format = 'retina' for 2x PNG figures, in your IPython config file or via the %config magic
Add display.FileLink and FileLinks for quickly displaying HTML links to local files
Cells have metadata, which can be edited via cell toolbars. This metadata can be used by external code (e.g. reveal.js or exporters), when examining the notebook
Fix an issue parsing LaTeX in markdown cells, which required users to type \\\, instead of \\
Notebook templates are rendered with Jinja instead of Tornado
file has been renamed %%writefile (%%file is deprecated)
ANSI (and VT100) color parsing has been improved in both performance and supported values
The static files path can be found as IPython.html.DEFAULT_STATIC_FILES_PATH, which may be changed by package managers
IPython’s CSS is installed in static/css/style.min.css (all style, including bootstrap), and static/css/ipython.min.css, which only has IPython’s own CSS. The latter file should be useful for embedding IPython notebooks in other pages, blogs, etc
The Print View has been removed. Users are encouraged to test ipython nbconvert to generate a static view
Javascript Components:
The javascript components used in the notebook have been updated significantly
updates to jQuery (2.0) and jQueryUI (1.10)
Update CodeMirror to 3.14
Twitter Bootstrap (2.3) for layout
Font-Awesome (3.1) for icons
highlight.js (7.3) for syntax highlighting
marked (0.2.8) for markdown rendering
require.js (2.1) for loading javascript
Some relevant changes that are results of this
Markdown cells now support GitHub-flavored Markdown (GFM), which includes ```python code blocks and tables
Notebook UI behaves better on more screen sizes
Various code cell input issues have been fixed
Kernel:
The kernel code has been substantially reorganized
New features in the kernel
Kernels support ZeroMQ IPC transport, not just TCP
The message protocol has added a top-level metadata field, used for information about messages
Add a data_pub message that functions much like display_pub, but publishes raw (usually pickled) data, rather than representations
Ensure that sys.stdout.encoding is defined in Kernels
Stdout from forked subprocesses should be forwarded to frontends (instead of crashing)
IPEP 13:
The KernelManager has been split into a KernelManager and a KernelClient. The Manager owns a kernel and starts / signals / restarts it. There is always zero or one KernelManager per Kernel. Clients communicate with Kernels via zmq channels, and there can be zero-to-many Clients connected to a Kernel at any given time
The KernelManager now automatically restarts the kernel when it dies, rather than requiring user input at the notebook or QtConsole UI (which may or may not exist at restart time)
In-process kernels:
The Python-language frontends, particularly the Qt console, may now communicate with in-process kernels, in addition to the traditional out-of-process kernels. An in-process kernel permits direct access to the kernel namespace, which is necessary in some applications. It should be understood, however, that the in-process kernel is not robust to bad user input and will block the main (GUI) thread while executing. Developers must decide on a case-by-case basis whether this tradeoff is appropriate for their application
Parallel:
IPython.parallel has had some refactoring as well. There are many improvements and fixes, but these are the major changes
Connections have been simplified. All ports and the serialization in use are written to the connection file, rather than the initial two-stage system
Serialization has been rewritten, fixing many bugs and dramatically improving performance serializing large containers
Load-balancing scheduler performance with large numbers of tasks has been dramatically improved
There should be fewer (hopefully zero) false-positives for engine failures
Increased compatibility with various use cases that produced serialization / argument errors with map, etc
The controller can attempt to resume operation if it has crashed, by passing ipcontroller --restore
Engines can monitor the Hub heartbeat, and shutdown if the Hub disappears for too long
add HTCondor support in launchers
QtConsole:
Various fixes, including improved performance with lots of text output, and better drag and drop support. The initial window size of the qtconsole is now configurable via IPythonWidget.width and IPythonWidget.height

New in IPython 0.13 (Nov 6, 2013)

Major Notebook improvements - new user interface and more:
The IPython Notebook, which has proven since its release to be wildly popular, has seen a massive amount of work in this release cycle, leading to a significantly improved user experience as well as many new features
The first user-visible change is a reorganization of the user interface; the left panel has been removed and was replaced by a real menu system and a toolbar with icons. Both the toolbar and the header above the menu can be collapsed to leave an unobstructed working area
New user interface for Notebook
The notebook handles very long outputs much better than before (this was a serious usability issue when running processes that generated massive amounts of output). Now, in the presence of outputs longer than ~100 lines, the notebook will automatically collapse to a scrollable area and the entire left part of this area controls the display: one click in this area will expand the output region completely, and a double-click will hide it completely. This figure shows both the scrolled and hidden modes
Scrolling and hiding of long output in the notebook
Note
The auto-folding of long outputs is disabled in Firefox due to bugs in its scrolling behavior. See PR #2047 for details
Uploading notebooks to the dashboard is now easier: in addition to drag and drop (which can be finicky sometimes), you can now click on the upload text and use a regular file dialog box to select notebooks to upload. Furthermore, the notebook dashboard now auto-refreshes its contents and offers buttons to shut down any running kernels (PR #1739)
Improved dashboard
Cluster management:
The notebook dashboard can now also start and stop clusters, thanks to a new tab in the dashboard user interface
Cluster management from the notebook dashboard
This interface allows, for each profile you have configured, to start and stop a cluster (and optionally override the default number of engines corresponding to that configuration). While this hides all error reporting, once you have a configuration that you know works smoothly, it is a very convenient interface for controlling your parallel resources
New notebook format:
The notebooks saved now use version 3 of our format, which supports heading levels as well as the concept of ‘raw’ text cells that are not rendered as Markdown. These will be useful with converters we are developing, to pass raw markup (say LaTeX). That conversion code is still under heavy development and not quite ready for prime time, but we welcome help on this front so that we can merge it for full production use as soon as possible
Note
v3 notebooks can not be read by older versions of IPython, but we provide a simple script that you can use in case you need to export a v3 notebook to share with a v2 user
JavaScript refactoring:
All the client-side JavaScript has been decoupled to ease reuse of parts of the machinery without having to build a full-blown notebook. This will make it much easier to communicate with an IPython kernel from existing web pages and to integrate single cells into other sites, without loading the full notebook document-like UI. PR #1711
This refactoring also enables the possibility of writing dynamic javascript widgets that are returned from Python code and that present an interactive view to the user, with callbacks in Javascript executing calls to the Kernel. This will enable many interactive elements to be added by users in notebooks
An example of this capability has been provided as a proof of concept in examples/widgets that lets you directly communicate with one or more parallel engines, acting as a mini-console for parallel debugging and introspection
Improved tooltips:
The object tooltips have gained some new functionality. By pressing tab several times, you can expand them to see more of a docstring, keep them visible as you fill in a function’s parameters, or transfer the information to the pager at the bottom of the screen. For the details, look at the example notebook 01_notebook_introduction.ipynb
Improved tooltips in the notebook
The new notebook tooltips
Other improvements to the Notebook:
These are some other notable small improvements to the notebook, in addition to many bug fixes and minor changes to add polish and robustness throughout
The notebook pager (the area at the bottom) is now resizeable by dragging its divider handle, a feature that had been requested many times by just about anyone who had used the notebook system. PR #1705
It is now possible to open notebooks directly from the command line; for example: ipython notebook path/ will automatically set path/ as the notebook directory, and ipython notebook path/foo.ipynb will further start with the foo.ipynb notebook opened. PR #1686
If a notebook directory is specified with --notebook-dir (or with the corresponding configuration flag NotebookManager.notebook_dir), all kernels start in this directory
Fix codemirror clearing of cells with Ctrl-Z; PR #1965
Text (markdown) cells now line wrap correctly in the notebook, making them much easier to edit PR #1330
PNG and JPEG figures returned from plots can be interactively resized in the notebook, by dragging them from their lower left corner. PR #1832
Clear In [] prompt numbers on “Clear All Output”. For more version-control-friendly .ipynb files, we now strip all prompt numbers when doing a “Clear all output”. This reduces the amount of noise in commit-to-commit diffs that would otherwise show the (highly variable) prompt number changes. PR #1621
The notebook server now requires two consecutive Ctrl-C within 5 seconds (or an interactive confirmation) to terminate operation. This makes it less likely that you will accidentally kill a long-running server by typing Ctrl-C in the wrong terminal. PR #1609
Using Ctrl-S (or Cmd-S on a Mac) actually saves the notebook rather than providing the fairly useless browser html save dialog. PR #1334
Allow accessing local files from the notebook (in urls), by serving any local file as the url files/. This makes it possible to, for example, embed local images in a notebook. PR #1211
Cell magics:
We have completely refactored the magic system, finally moving the magic objects to standalone, independent objects instead of being the mixin class we’d had since the beginning of IPython (PR #1732). Now, a separate base class is provided in IPython.core.magic.Magics that users can subclass to create their own magics. Decorators are also provided to create magics from simple functions without the need for object orientation. Please see the Magic command system docs for further details
All builtin magics now exist in a few subclasses that group together related functionality, and the new IPython.core.magics package has been created to organize this into smaller files
This cleanup was the last major piece of deep refactoring needed from the original 2001 codebase
We have also introduced a new type of magic function, prefixed with %% instead of %, which operates at the whole-cell level. A cell magic receives two arguments: the line it is called on (like a line magic) and the body of the cell below it
Cell magics are most natural in the notebook, but they also work in the terminal and qt console, with the usual approach of using a blank line to signal cell termination
For example, to time the execution of several statements
timeit x = 0 # setup
for i in range(100000)
x += i**2This is particularly useful to integrate code in another language, and cell magics already exist for shell scripts, Cython, R and Octave. Using %%script /usr/bin/foo, you can run a cell in any interpreter that accepts code via stdin
Another handy cell magic makes it easy to write short text files: %%file ~/save/to/here.txt
The following cell magics are now included by default; all those that use special interpreters (Perl, Ruby, bash, etc.) assume you have the requisite interpreter installed
run cell body with the underlying OS shell; this is similar to prefixing every line in the cell with
bash: run cell body under bash
capture: capture the output of the code in the cell (and stderr as well). Useful to run codes that produce too much output that you don’t even want scrolled
file: save cell body as a file
perl: run cell body using Perl
prun: run cell body with profiler (cell extension of %prun)
python3: run cell body using Python 3
ruby: run cell body using Ruby
script: run cell body with the script specified in the first line
sh: run cell body using sh
sx: run cell with system shell and capture process output (cell extension of %sx)
system: run cell with system shell (%%! is an alias to this)
timeit: time the execution of the cell (extension of %timeit)
This is what some of the script-related magics look like in action
Cluster management from the notebook dashboard
In addition, we have also a number of extensions that provide specialized magics. These typically require additional software to run and must be manually loaded via %load_ext , but are extremely useful. The following extensions are provided
Cython magics (extension cythonmagic)
This extension provides magics to automatically build and compile Python extension modules using the Cython language. You must install Cython separately, as well as a C compiler, for this to work. The examples directory in the source distribution ships with a full notebook demonstrating these capabilities
Cython magic
Octave magics (extension octavemagic)
This extension provides several magics that support calling code written in the Octave language for numerical computing. You can execute single-lines or whole blocks of Octave code, capture both output and figures inline (just like matplotlib plots), and have variables automatically converted between the two languages. To use this extension, you must have Octave installed as well as the oct2py package. The examples directory in the source distribution ships with a full notebook demonstrating these capabilities
Octave magic
R magics (extension rmagic)
This extension provides several magics that support calling code written in the R language for statistical data analysis. You can execute single-lines or whole blocks of R code, capture both output and figures inline (just like matplotlib plots), and have variables automatically converted between the two languages. To use this extension, you must have R installed as well as the rpy2 package that bridges Python and R. The examples directory in the source distribution ships with a full notebook demonstrating these capabilities
R magic
Tab completer improvements:
Useful tab-completion based on live inspection of objects is one of the most popular features of IPython. To make this process even more user-friendly, the completers of both the Qt console and the Notebook have been reworked
The Qt console comes with a new ncurses-like tab completer, activated by default, which lets you cycle through the available completions by pressing tab, or select a completion with the arrow keys (PR #1851)
ncurses-like completer, with highlighted selection
The new improved Qt console’s ncurses-like completer allows to easily navigate thought long list of completions
In the notebook, completions are now sourced both from object introspection and analysis of surrounding code, so limited completions can be offered for variables defined in the current cell, or while the kernel is busy (PR #1711)
We have implemented a new configurable flag to control tab completion on modules that provide the __all__ attribute
IPCompleter.limit_to__all__= Boolean
This instructs the completer to honor __all__ for the completion. Specifically, when completing on object., if True: only those names in obj.__all__ will be included. When False [default]: the __all__ attribute is ignored. PR #1529
Improvements to the Qt console:
The Qt console continues to receive improvements and refinements, despite the fact that it is by now a fairly mature and robust component. Lots of small polish has gone into it, here are a few highlights
A number of changes were made to the underlying code for easier integration into other projects such as Spyder (PR #2007, PR #2024)
Improved menus with a new Magic menu that is organized by magic groups (this was made possible by the reorganization of the magic system internals). PR #1782
Allow for restarting kernels without clearing the qtconsole, while leaving a visible indication that the kernel has restarted. PR #1681
Allow the native display of jpeg images in the qtconsole. PR #1643
Parallel:
The parallel tools have been improved and fine-tuned on multiple fronts. Now, the creation of an IPython.parallel.Client object automatically activates a line and cell magic function px that sends its code to all the engines. Further magics can be easily created with the Client.activate() method, to conveniently execute code on any subset of engines. PR #1893
The %%px cell magic can also be given an optional targets argument, as well as a --out argument for storing its output
A new magic has also been added, %pxconfig, that lets you configure various defaults of the parallel magics. As usual, type %pxconfig? for details
The exception reporting in parallel contexts has been improved to be easier to read. Now, IPython directly reports the remote exceptions without showing any of the internal execution parts
Improved parallel exceptions
The parallel tools now default to using NoDB as the storage backend for intermediate results. This means that the default usage case will have a significantly reduced memory footprint, though certain advanced features are not available with this backend. For more details, see IPython’s Task Database
The parallel magics now display all output, so you can do parallel plotting or other actions with complex display. The px magic has now both line and cell modes, and in cell mode finer control has been added about how to collate output from multiple engines. PR #1768
There have also been incremental improvements to the SSH launchers
add to_send/fetch steps for moving connection files around
add SSHProxyEngineSetLauncher, for invoking to ipcluster engines on a remote host. This can be used to start a set of engines via PBS/SGE/MPI remotely
This makes the SSHLauncher usable on machines without shared filesystems
A number of ‘sugar’ methods/properties were added to AsyncResult that are quite useful (PR #1548) for everday work
ar.wall_time = received - submitted
ar.serial_time = sum of serial computation time
ar.elapsed = time since submission (wall_time if done)
ar.progress = (int) number of sub-tasks that have completed
len(ar) = # of tasks
ar.wait_interactive(): prints progress
Added Client.spin_thread() / stop_spin_thread() for running spin in a background thread, to keep zmq queue clear. This can be used to ensure that timing information is as accurate as possible (at the cost of having a background thread active)
Set TaskScheduler.hwm default to 1 instead of 0. 1 has more predictable/intuitive behavior, if often slower, and thus a more logical default. Users whose workloads require maximum throughput and are largely homogeneous in time per task can make the optimization themselves, but now the behavior will be less surprising to new users. PR #1294
Kernel/Engine unification:
This is mostly work ‘under the hood’, but it is actually a major achievement for the project that has deep implications in the long term: at last, we have unified the main object that executes as the user’s interactive shell (which we refer to as the IPython kernel) with the objects that run in all the worker nodes of the parallel computing facilities (the IPython engines). Ever since the first implementation of IPython’s parallel code back in 2006, we had wanted to have these two roles be played by the same machinery, but a number of technical reasons had prevented that from being true
In this release we have now merged them, and this has a number of important consequences
It is now possible to connect any of our clients (qtconsole or terminal console) to any individual parallel engine, with the exact behavior of working at a ‘regular’ IPython console/qtconsole. This makes debugging, plotting, etc. in parallel scenarios vastly easier
Parallel engines can always execute arbitrary ‘IPython code’, that is, code that has magics, shell extensions, etc. In combination with the %%px magics, it is thus extremely natural for example to send to all engines a block of Cython or R code to be executed via the new Cython and R magics. For example, this snippet would send the R block to all active engines in a cluster
R code goes hereIt is possible to embed not only an interactive shell with the IPython.embed() call as always, but now you can also embed a kernel with IPython.embed_kernel(). Embedding an IPython kernel in an application is useful when you want to use IPython.embed() but don’t have a terminal attached on stdin and stdout
The new IPython.parallel.bind_kernel() allows you to promote Engines to listening Kernels, and connect QtConsoles to an Engine and debug it directly
In addition, having a single core object through our entire architecture also makes the project conceptually cleaner, easier to maintain and more robust. This took a lot of work to get in place, but we are thrilled to have this major piece of architecture finally where we’d always wanted it to be
Official Public API:
We have begun organizing our API for easier public use, with an eye towards an official IPython 1.0 release which will firmly maintain this API compatible for its entire lifecycle. There is now an IPython.display module that aggregates all display routines, and the IPython.config namespace has all public configuration tools. We will continue improving our public API layout so that users only need to import names one level deeper than the main IPython package to access all public namespaces
IPython notebook file icons:
The directory docs/resources in the source distribution contains SVG and PNG versions of our file icons, as well as an Info.plist.example file with instructions to install them on Mac OSX. This is a first draft of our icons, and we encourage contributions from users with graphic talent to improve them in the future
IPython notebook file icon
New top-level locate command:
Add locate entry points; these would be useful for quickly locating IPython directories and profiles from other (non-Python) applications. PR #1762
Examples
ipython locate
Users/me/.ipython
ipython locate profile foo
Users/me/.ipython/profile_foo
ipython locate profile
Users/me/.ipython/profile_default
ipython locate profile dne
ProfileLocate] Profile u'dne' not found.Other new features and improvements:
install_ext: A new magic function to install an IPython extension from a URL. E.g. %install_ext https://bitbucket.org/birkenfeld/ipython-physics/raw/default/physics.py
The %loadpy magic is no longer restricted to Python files, and has been renamed %load. The old name remains as an alias
New command line arguments will help external programs find IPython folders: ipython locate finds the user’s IPython directory, and ipython locate profile foo finds the folder for the ‘foo’ profile (if it exists)
The IPYTHON_DIR environment variable, introduced in the Great Reorganization of 0.11 and existing only in versions 0.11-0.13, has been deprecated. As described in PR #1167, the complexity and confusion of migrating to this variable is not worth the aesthetic improvement. Please use the historical IPYTHONDIR environment variable instead
The default value of interactivity passed from run_cell() to run_ast_nodes() is now configurable
New %alias_magic function to conveniently create aliases of existing magics, if you prefer to have shorter names for personal use
We ship unminified versions of the JavaScript libraries we use, to better comply with Debian’s packaging policies
Simplify the information presented by obj?/obj?? to eliminate a few redundant fields when possible. PR #2038
Improved continuous integration for IPython. We now have automated test runs on Shining Panda and Travis-CI, as well as Tox support
The vim-ipython functionality (externally developed) has been updated to the latest version
The %save magic now has a -f flag to force overwriting, which makes it much more usable in the notebook where it is not possible to reply to interactive questions from the kernel. PR #1937
Use dvipng to format sympy.Matrix, enabling display of matrices in the Qt console with the sympy printing extension. PR #1861
Our messaging protocol now has a reasonable test suite, helping ensure that we don’t accidentally deviate from the spec and possibly break third-party applications that may have been using it. We encourage users to contribute more stringent tests to this part of the test suite. PR #1627
Use LaTeX to display, on output, various built-in types with the SymPy printing extension. PR #1399
Add Gtk3 event loop integration and example. PR #1588
clear_output improvements, which allow things like progress bars and other simple animations to work well in the notebook (PR #1563)
clear_output() clears the line, even in terminal IPython, the QtConsole and plain Python as well, by printing r to streams
clear_output() avoids the flicker in the notebook by adding a delay, and firing immediately upon the next actual display message
display_javascript hides its output_area element, so using display to run a bunch of javascript doesn’t result in ever-growing vertical space
Add simple support for running inside a virtualenv. While this doesn’t supplant proper installation (as users should do), it helps ad-hoc calling of IPython from inside a virtualenv. PR #1388
Major Bugs fixed:
In this cycle, we have closed over 740 issues, but a few major ones merit special mention
The %pastebin magic has been updated to point to gist.github.com, since unfortunately http://paste.pocoo.org has closed down. We also added a -d flag for the user to provide a gist description string. PR #1670
Fix %paste that would reject certain valid inputs. PR #1258
Fix sending and receiving of Numpy structured arrays (those with composite dtypes, often used as recarrays). PR #2034
Reconnect when the websocket connection closes unexpectedly. PR #1577
Fix truncated representation of objects in the debugger by showing at least 80 characters’ worth of information. PR #1793
Fix logger to be Unicode-aware: logging could crash ipython if there was unicode in the input. PR #1792
Fix images missing from XML/SVG export in the Qt console. PR #1449
Fix deepreload on Python 3. PR #1625, as well as having a much cleaner and more robust implementation of deepreload in general. PR #1457
Backwards incompatible changes:
The exception IPython.core.error.TryNext previously accepted arguments and keyword arguments to be passed to the next implementation of the hook. This feature was removed as it made error message propagation difficult and violated the principle of loose coupling

New in IPython 0.12 (Apr 12, 2012)

Other important new features:
SSH Tunnels: In 0.11, the IPython.parallel Client could tunnel its connections to the Controller via ssh. Now, the QtConsole supports ssh tunneling, as do parallel engines.
relaxed command-line parsing: 0.11 was released with overly-strict command-line parsing, preventing the ability to specify arguments with spaces, e.g. ipython --pylab qt or ipython -c "print 'hi'". This has been fixed, by using argparse. The new parsing is a strict superset of 0.11, so any commands in 0.11 should still work in 0.12.
HistoryAccessor: The HistoryManager class for interacting with your IPython SQLite history database has been split, adding a parent HistoryAccessor class, so that users can write code to access and search their IPython history without being in an IPython session (PR #824).
kernel %gui and %pylab: The %gui and %pylab magics have been restored to the IPython kernel (e.g. in the qtconsole or notebook). This allows activation of pylab-mode, or eventloop integration after starting the kernel, which was unavailable in 0.11. Unlike in the terminal, this can be set only once, and cannot be changed.
config: A new %config magic has been added, giving easy access to the IPython configuration system at runtime (PR #923).
Multiline History: Multiline readline history has been restored to the Terminal frontend by default (PR #838).
store: The %store magic from earlier versions has been updated and re-enabled (storemagic; PR #1029). To autorestore stored variables on startup, specify c.StoreMagic.autorestore = True in ipython_config.py.
Major Bugs fixed:
In this cycle, we have closed over 500 issues, but a few major ones merit special mention:
Simple configuration errors should no longer crash IPython. In 0.11, errors in config files, as well as invalid trait values, could crash IPython. Now, such errors are reported, and help is displayed.
Certain SyntaxErrors no longer crash IPython (e.g. just typing keywords, such as return, break, etc.). See #704.
IPython path utils, such as get_ipython_dir() now check for write permissions, so IPython should function on systems where the default path resolution might point to a read-only location, such as HOMESHARE on Windows (#669).
raw_input() now works in the kernel when multiple frontends are in use. The request will be sent to the frontend that made the request, and an exception is raised if that frontend does not support stdin requests (e.g. the notebook) (#673).
zmq version detection no longer uses simple lexicographical comparison to check minimum version, which prevents 0.11 from working with pyzmq-2.1.10 (PR #758).
A bug in PySide < 1.0.7 caused crashes on OSX when tooltips were shown (#711). these tooltips are now disabled on old PySide (PR #963).
IPython no longer crashes when started on recent versions of Python 3 in Windows (#737).
Instances of classes defined interactively can now be pickled (#29;
PR #648). Note that pickling saves a reference to the class definition, so unpickling the instances will only work where the class has been defined.
Backwards incompatible changes
IPython connection information is no longer specified via ip/port directly, rather via json connection files. These files are stored in the security directory, and enable us to turn on HMAC message authentication by default, significantly improving the security of kernels. Various utility functions have been added to IPython.lib.kernel, for easier connecting to existing kernels.
KernelManager now has one ip, and several port traits, rather than several ip/port pair _addr traits. This better matches the rest of the code, where the ip cannot not be set separately for each channel.
Custom prompts are now configured using a new class,
PromptManager, which has traits for in_template, in2_template (the ...: continuation prompt), out_template and rewrite_template. This uses Python’s string formatting system, so you can use {time} and {cwd}, although we have preserved the abbreviations from previous versions, e.g. \# (prompt number) and \w (working directory). For the list of available fields, refer to the source of IPython/core/prompts.py.
The class inheritance of the Launchers in IPython.parallel.apps.launcher used by ipcluster has changed, so that trait names are more consistent across batch systems. This may require a few renames in your config files, if you customized the command-line args for launching controllers and engines. The configurable names have also been changed to be clearer that they point to class names, and can now be specified by name only, rather than requiring the full import path of each class, e.g.:
IPClusterEngines.engine_launcher = 'IPython.parallel.apps.launcher.MPIExecEngineSetLauncher'
IPClusterStart.controller_launcher = 'IPython.parallel.apps.launcher.SSHControllerLauncher'
would now be specified as:
IPClusterEngines.engine_launcher_class = 'MPI'
IPClusterStart.controller_launcher_class = 'SSH'
The full path will still work, and is necessary for using custom launchers not in IPython’s launcher module.
Further, MPIExec launcher names are now prefixed with just MPI, to better match other batch launchers, and be generally more intuitive. The MPIExec names are deprecated, but continue to work.
For embedding a shell, note that the parameters user_global_ns and global_ns have been deprectated in favour of user_module and module respsectively. The new parameters expect a module-like object, rather than a namespace dict. The old parameters remain for backwards compatibility, although user_global_ns is now ignored. The user_ns parameter works the same way as before, and calling embed() with no arguments still works as before.

New in IPython 0.11 (Apr 12, 2012)

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 line-oriented terminal simply can not support, such as inline figures, full multiline editing with syntax highlighting, graphical tooltips for function calls and much more. This development was sponsored by Enthought Inc.. See below for details.
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, more details below.
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 the GUI support section for more details.
A two-process architecture. The Qt console is the first use of 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 messaging 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 docs/examples/vim for the full details.
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
Improved unicode support. We closed many bugs related to unicode input.
Python 3. IPython now runs on Python 3.x. See Python 3 support 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 `` ...:``).
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 removes ambiguity and helps the Python 3 transition.
New magic %loadpy loads a python file from disk or web URL into the current input buffer.
New magic %pastebin for sharing code via the ‘Lodge it’ pastebin.
New magic %precision for controlling float and numpy pretty printing.
IPython applications initiate logging, so any object can gain access to a the logger of the currently running Application with:
from IPython.config.application import Application
logger = Application.instance().log
You can now get help on an object halfway through typing a command. For instance, typing a = zip? shows the details of zip(). It also leaves the command at the next prompt so you can carry on with it.
The input history is now written to an SQLite database. The API for retrieving items from the history has also been redesigned.
The IPython.extensions.pretty extension has been moved out of quarantine and fully updated to the new extension API.
New magics for loading/unloading/reloading extensions have been added: %load_ext, %unload_ext and %reload_ext.
The configuration system and configuration files are brand new. See the configuration system documentation for more details.
The InteractiveShell class is now a 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 ipmaker module.
The methods of InteractiveShell have been organized into sections to make it easier to turn more sections of functionality into components.
The embedded shell has been refactored into a truly standalone subclass of InteractiveShell called InteractiveShellEmbed. All embedding logic has been taken out of the base class and put into the embedded subclass.
Added methods of InteractiveShell to help it cleanup after itself. The cleanup() method controls this. We couldn’t do this in __del__() because we have cycles in our object graph that prevent it from being called.
Created a new module IPython.utils.importstring for resolving strings like foo.bar.Bar to the actual class.
Completely refactored the IPython.core.prefilter module into 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 (IPython.core.alias).
New top level embed() function that can be called to embed IPython at any place in user’s code. On the first call it will create an InteractiveShellEmbed instance and call it. In later calls, it just calls the previously created InteractiveShellEmbed.
Created a configuration system (IPython.config.configurable) that is based on IPython.utils.traitlets. Configurables are arranged into a runtime containment tree (not inheritance) that i) automatically propagates configuration information and ii) allows singletons to discover each other in a loosely coupled manner. In the future all parts of IPython will be subclasses of Configurable. All IPython developers should become familiar with the config system.
Created a new Config for holding configuration information. This is a dict like class with a few extras: i) it supports attribute style access, ii) it has a merge function that merges two Config instances recursively and iii) it will automatically create sub-Config instances for attributes that start with an uppercase character.
Created new configuration loaders in IPython.config.loader. These loaders provide a unified loading interface for all configuration information including command line arguments and configuration files. We have two default implementations based on argparse and plain python files. These are used to implement the new configuration system.
Created a top-level Application class in IPython.core.application that is designed to encapsulate the starting of any basic Python program. An application loads and merges all the configuration objects, constructs the main application, configures and initiates logging, and creates and configures any Configurable instances and then starts the application running. An extended BaseIPythonApplication class adds logic for handling the IPython directory as well as profiles, and all IPython entry points extend it.
The Type and Instance traitlets now handle classes given as strings, like foo.bar.Bar. This is needed for forward declarations. But, this was implemented in a careful way so that string to class resolution is done at a single point, when the parent HasTraitlets is instantiated.
IPython.utils.ipstruct has been refactored to be a subclass of dict. It also now has full docstrings and doctests.
Created a Traits like implementation in 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 IPython.lib.inputhook to manage the integration with GUI event loops using PyOS_InputHook. See the docstrings in this module or the main IPython docs for details.
For users, GUI event loop integration is now handled through the new %gui magic command. Type %gui? at an IPython prompt for documentation.
For developers IPython.lib.inputhook provides a simple interface for managing the event loops in their interactive GUI applications. Examples can be found in our docs/examples/lib directory.

New in IPython 0.10.2 (Apr 12, 2012)

New in IPython 0.10.1 (Apr 12, 2012)

IPython 0.10.1 was released October 11, 2010, over a year after version 0.10. This is mostly a bugfix release, since after version 0.10 was released, the development team’s energy has been focused on the 0.11 series. We have nonetheless tried to backport what fixes we could into 0.10.1, as it remains the stable series that many users have in production systems they rely on.
Since the 0.11 series changes many APIs in backwards-incompatible ways, we are willing to continue maintaining the 0.10.x series. We don’t really have time to actively write new code for 0.10.x, but we are happy to accept patches and pull requests on the IPython github site. If sufficient contributions are made that improve 0.10.1, we will roll them into future releases. For this purpose, we will have a branch called 0.10.2 on github, on which you can base your contributions.
For this release, we applied approximately 60 commits totaling a diff of over 7000 lines:
0.10.1)amirbar[dist]> git diff --oneline rel-0.10.. | wc -l
7296
Highlights of this release:
The only significant new feature is that IPython’s parallel computing machinery now supports natively the Sun Grid Engine and LSF schedulers. This work was a joint contribution from Justin Riley, Satra Ghosh and Matthieu Brucher, who put a lot of work into it. We also improved traceback handling in remote tasks, as well as providing better control for remote task IDs.
New IPython Sphinx directive contributed by John Hunter. You can use this directive to mark blocks in reSructuredText documents as containing IPython syntax (including figures) and the will be executed during the build:
In [2]: plt.figure() # ensure a fresh figure
savefig psimple.png width=4in
In [3]: plt.plot([1,2,3])
Out[3]: []
Various fixes to the standalone ipython-wx application.
Now (2010) that argparse has become part of Python 2.7 this will be less of an issue, but Steven’s relicensing allowed us to start updating IPython to using argparse well before Python 2.7. Many thanks!
Robustness improvements so that IPython doesn’t crash if the readline library is absent (though obviously a lot of functionality that requires readline will not be available).
Improvements to tab completion in Emacs with Python 2.6.
Logging now supports timestamps (see %logstart? for full details).
A long-standing and quite annoying bug where parentheses would be added to print statements, under Python 2.5 and 2.6, was finally fixed.
Improved handling of libreadline on Apple OSX.
Fix reload method of IPython demos, which was broken.
Fixes for the ipipe/ibrowse system on OSX.
Fixes for Zope profile.
Fix %timeit reporting when the time is longer than 1000s.
Avoid lockups with ? or ?? in SunOS, due to a bug in termios.
The usual assortment of miscellaneous bug fixes and small improvements.

New in IPython 0.10 (Apr 12, 2012)

New features:
New %paste magic automatically extracts current contents of clipboard and pastes it directly, while correctly handling code that is indented or prepended with >>> or ... python prompt markers.
IPython ‘demos’, created with the IPython.demo module, can now be created from files on disk or strings in memory.
Added find_cmd() function to IPython.platutils module, to find commands in a cross-platform manner.
Many improvements and fixes to Gaël Varoquaux’s ipythonx, a WX-based lightweight IPython instance that can be easily embedded in other WX applications. These improvements have made it possible to now have an embedded IPython in Mayavi and other tools.
MultiengineClient objects now have a benchmark() method.
The manual now includes a full set of auto-generated API documents from the code sources, using Sphinx and some of our own support code. We are now using the Numpy Documentation Standard for all docstrings, and we have tried to update as many existing ones as possible to this format.
The new IPython.Extensions.ipy_pretty extension by Robert Kern provides configurable pretty-printing.
It can optionally run in a thread, and this can be toggled at runtime (allowing the loading of Matplotlib in a running session without ill effects).
IPython includes a copy of Steven Bethard’s argparse in the IPython.external package, so we can use it internally and it is also available to any IPython user. By installing it in this manner, we ensure zero conflicts with any system-wide installation you may already have while minimizing external dependencies for new users. In IPython 0.10, We ship argparse version 1.0.
An improved and much more robust test suite, that runs groups of tests in separate subprocesses using either Nose or Twisted’s trial runner to ensure proper management of Twisted-using code. The test suite degrades gracefully if optional dependencies are not available, so that the iptest command can be run with only Nose installed and nothing else. We also have more and cleaner test decorators to better select tests depending on runtime conditions, do setup/teardown, etc.
The new ipcluster now has a fully working ssh mode that should work on Linux, Unix and OS X. !
The wonderful TextMate editor can now be used with �it on OS X. Thanks to Matt Foster for this patch.
The documentation regarding parallel uses of IPython, including MPI and PBS, has been significantly updated and improved.
The developer guidelines in the documentation have been updated to explain our workflow using bzr and Launchpad.
Fully refactored ipcluster command line program for starting IPython clusters. This new version is a complete rewrite and 1) is fully cross platform (we now use Twisted’s process management), 2) has much improved performance, 3) uses subcommands for different types of clusters, 4) uses argparse for parsing command line options, 5) has better support for starting clusters using mpirun, 6) has experimental support for starting engines using PBS. It can also reuse FURL files, by appropriately passing options to its subcommands. However, this new version of ipcluster should be considered a technology preview. We plan on changing the API in significant ways before it is final.
Full description of the security model added to the docs.
cd completer: show bookmarks if no other completions are available.
sh profile: easy way to give ‘title’ to prompt: assign to variable ‘_prompt_title’. It looks like this:
1> _prompt_title = 'sudo!'
sudo![~]|2>
edit: If you do ‘�it pasted_block’, pasted_block variable gets updated with new data (so repeated editing makes sense)
Bug fixes:
Fix #368719, removed top-level debian/ directory to make the job of Debian packagers easier.
Fix #291143 by including man pages contributed by Stephan Peijnik from the Debian project.
Fix #358202, effectively a race condition, by properly synchronizing file creation at cluster startup time.
timeit now handles correctly functions that take a long time to execute even the first time, by not repeating them.
Fix #239054, releasing of references after exiting.
Fix #341726
Fix #269966. This long-standing and very difficult bug (which is actually a problem in Python itself) meant long-running sessions would inevitably grow in memory size, often with catastrophic consequences if users had large objects in their scripts. Now, using %run repeatedly should not cause any memory leaks.
Fix #295371, bug in %history.
Improved support for py2exe.
Fix #270856: IPython hangs with PyGTK
Fix #270998: A magic with no docstring breaks the ‘%magic magic’
fix #271684: -c startup commands screw up raw vs. native history
Numerous bugs on Windows with the new ipcluster have been fixed.
The ipengine and ipcontroller scripts now handle missing furl files more gracefully by giving better error messages.
rehashx: Aliases no longer contain dots. python3.0 binary will create alias python30. Fixes: #259716 “commands with dots in them don’t work”
cpaste: %cpaste -r repeats the last pasted block. The block is assigned to pasted_block even if code raises exception.
Bug #274067 ‘The code in get_home_dir is broken for py2exe’ was fixed.
Many other small bug fixes not listed here by number (see the bzr log for more info).
Backwards incompatible changes
ipykit and related files were unmaintained and have been removed.
The IPython.genutils.doctest_reload() does not actually call reload(doctest) anymore, as this was causing many problems with the test suite. It still resets doctest.master to None.
While we have not deliberately broken Python 2.4 compatibility, only minor testing was done with Python 2.4, while 2.5 and 2.6 were fully tested. But if you encounter problems with 2.4, please do report them as bugs.
The ipcluster now requires a mode argument; for example to start a cluster on the local machine with 4 engines, you must now type:
ipcluster local -n 4
The controller now has a -r flag that needs to be used if you want to reuse existing furl files. Otherwise they are deleted (the default).
Remove ipy_leo.py. You can use easy_install ipython-extension to get it. (done to decouple it from ipython release cycle)

New in IPython 0.9.1 (Apr 12, 2012)

New in IPython 0.9 (Apr 12, 2012)

New features:
All furl files and security certificates are now put in a read-only directory named ~./ipython/security.
A single function get_ipython_dir(), in IPython.genutils that determines the user’s IPython directory in a robust manner.
Laurent’s WX application has been given a top-level script called ipython-wx, and it has received numerous fixes. We expect this code to be architecturally better integrated with Gael’s WX ‘ipython widget’ over the next few releases.
The Editor synchronization work by Vivian De Smedt has been merged in. This code adds a number of new editor hooks to synchronize with editors under Windows.
A new, still experimental but highly functional, WX shell by Gael Varoquaux. This work was sponsored by Enthought, and while it’s still very new, it is based on a more cleanly organized arhictecture of the various IPython components. We will continue to develop this over the next few releases as a model for GUI components that use IPython.
Another GUI frontend, Cocoa based (Cocoa is the OSX native GUI framework), authored by Barry Wark. Currently the WX and the Cocoa ones have slightly different internal organizations, but the whole team is working on finding what the right abstraction points are for a unified codebase.
As part of the frontend work, Barry Wark also implemented an experimental event notification system that various ipython components can use. In the next release the implications and use patterns of this system regarding the various GUI options will be worked out.
IPython finally has a full test system, that can test docstrings with IPython-specific functionality. There are still a few pieces missing for it to be widely accessible to all users (so they can run the test suite at any time and report problems), but it now works for the developers. We are working hard on continuing to improve it, as this was probably IPython’s major Achilles heel (the lack of proper test coverage made it effectively impossible to do large-scale refactoring). The full test suite can now be run using the iptest command line program.
The notion of a task has been completely reworked. An ITask interface has been created. This interface defines the methods that tasks need to implement. These methods are now responsible for things like submitting tasks and processing results. There are two basic task types: IPython.kernel.task.StringTask (this is the old Task object, but renamed) and the new IPython.kernel.task.MapTask, which is based on a function.
A new interface, IPython.kernel.mapper.IMapper has been defined to standardize the idea of a map method. This interface has a single map method that has the same syntax as the built-in map. We have also defined a mapper factory interface that creates objects that implement IPython.kernel.mapper.IMapper for different controllers. Both the multiengine and task controller now have mapping capabilties.
The parallel function capabilities have been reworks. The major changes are that i) there is now an @parallel magic that creates parallel functions, ii) the syntax for mulitple variable follows that of map, iii) both the multiengine and task controller now have a parallel function implementation.
All of the parallel computing capabilities from ipython1-dev have been merged into IPython proper. This resulted in the following new subpackages: IPython.kernel, IPython.kernel.core, IPython.config, IPython.tools and IPython.testing.
As part of merging in the ipython1-dev stuff, the setup.py script and friends have been completely refactored. Now we are checking for dependencies using the approach that matplotlib uses.
The documentation has been completely reorganized to accept the documentation from ipython1-dev.
We have switched to using Foolscap for all of our network protocols in IPython.kernel. This gives us secure connections that are both encrypted and authenticated.
We have a brand new COPYING.txt files that describes the IPython license and copyright. The biggest change is that we are putting “The IPython Development Team” as the copyright holder. We give more details about exactly what this means in this file. All developer should read this and use the new banner in all IPython source code files.
sh profile: ./foo runs foo as system command, no need to do !./foo anymore
String lists now support sort(field, nums = True) method (to easily sort system command output). Try it with a = !ls -l ; a.sort(1, nums=1).
cpaste foo’ now assigns the pasted block as string list, instead of string
The ipcluster script now run by default with no security. This is done because the main usage of the script is for starting things on localhost. Eventually when ipcluster is able to start things on other hosts, we will put security back.
cd –foo’ searches directory history for string foo, and jumps to that dir. Last part of dir name is checked first. If no matches for that are found, look at the whole path.
Bug fixes:
The Windows installer has been fixed. Now all IPython scripts have .bat versions created. Also, the Start Menu shortcuts have been updated.
The colors escapes in the multiengine client are now turned off on win32 as they don’t print correctly.
The IPython.kernel.scripts.ipengine script was exec’ing mpi_import_statement incorrectly, which was leading the engine to crash when mpi was enabled.
A few subpackages had missing __init__.py files.
The documentation is only created if Sphinx is found. Previously, the setup.py script would fail if it was missing.
Greedy cd completion has been disabled again (it was enabled in 0.8.4) as it caused problems on certain platforms.
Backwards incompatible changes
The clusterfile options of the ipcluster command has been removed as it was not working and it will be replaced soon by something much more robust.
The IPython.kernel configuration now properly find the user’s IPython directory.
In ipapi, the make_user_ns() function has been replaced with make_user_namespaces(), to support dict subclasses in namespace creation.
IPython.kernel.client.Task has been renamed IPython.kernel.client.StringTask to make way for new task types.
The keyword argument style has been renamed dist in scatter, gather and map.
Renamed the values that the rename dist keyword argument can have from ‘basic’ to ‘b’.
IPython has a larger set of dependencies if you want all of its capabilities. See the setup.py script for details.
The constructors for IPython.kernel.client.MultiEngineClient and IPython.kernel.client.TaskClient no longer take the (ip,port) tuple. Instead they take the filename of a file that contains the FURL for that client. If the FURL file is in your IPYTHONDIR, it will be found automatically and the constructor can be left empty.
The asynchronous clients in IPython.kernel.asyncclient are now created using the factory functions get_multiengine_client() and get_task_client(). These return a Deferred to the actual client.
The command line options to ipcontroller and ipengine have changed to reflect the new Foolscap network protocol and the FURL files. Please see the help for these scripts for details.
The configuration files for the kernel have changed because of the Foolscap stuff. If you were using custom config files before, you should delete them and regenerate new ones.